/*
 *  Copyright (c) 2014 Lincong All rights reserved.
 *  This software is the confidential and proprietary information of Lincong.
 *  You shall not disclose such Confidential
 *  Information and shall use it only in accordance with the terms of the license
 *  agreement you entered into with Lincong.
 *   Mail: Lincong <lincong1987@gmail.com>
 *     QQ: 159257119
 *  Phone: 15925711961
 *  This File Created On 2014-1-19 0:09:53.
 *  Document   : firebird.class-1.0.1.js
 *  Encoding   : UTF-8
 *  $Id$
 *  this file is based on EXTJS 4.2.1
 */

define(function (require, exports, module) {

	var $ = require("jquery");
	var firebird = require("firebird");
	var tmpl = require("tmpl");

	// @tag foundation,core
	// @define Firebird

	/**
	 * @class Firebird      * @singleton
	 */
	var Firebird = {};
	Firebird._startTime = new Date().getTime();
	(function () {
		var global = window,
			objectPrototype = Object.prototype,
			toString = objectPrototype.toString,
			enumerables = true,
			enumerablesTest = {
				toString: 1
			},
			emptyFn = function () {
			},
		// This is the "$previous" method of a hook function on an instance. When called, it
		// calls through the class prototype by the name of the called method.
			callOverrideParent = function () {
				var method = callOverrideParent.caller.caller; // skip callParent (our caller)
				return method.$owner.prototype[method.$name].apply(this, arguments);
			},
			i,
			nonWhitespaceRe = /\S/,
			FirebirdApp,
			iterableRe = /\[object\s*(?:Array|Arguments|\w*Collection|\w*List|HTML\s+document\.all\s+class)\]/;

		Function.prototype.$extIsFunction = true;

		Firebird.global = global;

		/**
		 * Firebird.Tmpl.complie
		 */
			//Firebird.Tmpl.complie

		Firebird.Tmpl = tmpl;

		for (i in enumerablesTest) {
			enumerables = null;
		}

		if (enumerables) {
			enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
				'toLocaleString', 'toString', 'constructor'];
		}

		/**
		 * 这个数组是为了兼容旧的浏览器
		 * @property {String[]}
		 */
		Firebird.enumerables = enumerables;

		/**
		 * 复制所有的属性
		 * Copies all the properties of config to the specified object.
		 * Note that if recursive merging and cloning without referencing the original objects / arrays is needed, use
		 * {@link Firebird.Object#merge} instead.
		 * @param {Object} object The receiver of the properties
		 * @param {Object} config The source of the properties
		 * @param {Object} [defaults] A different object that will also be applied for default values
		 * @return {Object} returns obj
		 */
		Firebird.apply = function (object, config, defaults) {
			if (defaults) {
				Firebird.apply(object, defaults);
			}

			if (object && config && typeof config === 'object') {
				var i, j, k;

				for (i in config) {
					object[i] = config[i];
				}

				if (enumerables) {
					for (j = enumerables.length; j--;) {
						k = enumerables[j];
						if (config.hasOwnProperty(k)) {
							object[k] = config[k];
						}
					}
				}
			}

			return object;
		};

		Firebird.buildSettings = Firebird.apply({
			baseCSSPrefix: 'fb-'
		}, Firebird.buildSettings || {});

		Firebird.supports = {
			TimeoutActualLateness: true
		};

		Firebird.apply(Firebird, {
			get: function (id) {
				return $("#" + id);
			},
			/**
			 *
			 * @param pattern
			 * @param spliter
			 * @returns {string}
			 */
			uuid: function (pattern, spliter) {
				pattern = (pattern || "xxxx-xxxx-xxxx-xxxx").split(spliter || "");
				for (var d = 0, e = a.length; d < e; d++)switch (a[d]) {
					case "x":
						pattern[d] = Math.floor(16 * Math.random()).toString(16);
						break;
					case "y":
						pattern[d] = (Math.floor(4 * Math.random()) + 8).toString(16)
				}
				return pattern.join("");
			},
			/**
			 * @property {String} [name='Firebird']
			 * <p>全局命名空间（）的属性名</p>
			 * <p>The name of the property in the global namespace (The <code>window</code> in browser environments) which refers to the current instance of Firebird.</p>
			 * <p>This is usually <code>"Firebird"</code>, but if a sandboxed build of ExtJS is being used, this will be an alternative name.</p>
			 * <p>If code is being generated for use by <code>eval</code> or to create a <code>new Function</code>, and the global instance
			 * of Firebird must be referenced, this is the name that should be built into the code.</p>
			 */
			name: Firebird.sandboxName || 'Firebird',
			/**
			 * @property {Function}
			 * 一个可重用的空函数
			 */
			emptyFn: emptyFn,
			/**
			 * A reusable identity function. The function will always return the first argument, unchanged.
			 */
			identityFn: function (o) {
				return o;
			},
			/**
			 * 一个
			 * A zero length string which will pass a truth test. Useful for passing to methods
			 * which use a truth test to reject <i>falsy</i> values where a string value must be cleared.
			 */
			emptyString: new String(),
			baseCSSPrefix: Firebird.buildSettings.baseCSSPrefix,
			/**
			 * Copies all the properties of config to object if they don't already exist.
			 * @param {Object} object The receiver of the properties
			 * @param {Object} config The source of the properties
			 * @return {Object} returns obj
			 */
			applyIf: function (object, config) {
				var property;

				if (object) {
					for (property in config) {
						if (object[property] === undefined) {
							object[property] = config[property];
						}
					}
				}

				return object;
			},
			/**
			 * 迭代一个数组或一个对象。 如果给出的数组或对象是可迭代的，那这个方法会委托给
			 * {@link Firebird.Array#each Firebird.Array.each} 和 {@link Firebird.Object#each Firebird.Object.each}。
			 *
			 * @param {Object/Array} object 将被迭代的数组或对象。
			 * @param {Function} fn 每次循环中将被调用的函数. See and {@link Firebird.Array#each Firebird.Array.each} and
			 * {@link Firebird.Object#each Firebird.Object.each} for detailed lists of arguments passed to this function depending on the given object
			 * type that is being iterated.
			 * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
			 * Defaults to the object being iterated itself.
			 * @markdown
			 */
			iterate: function (object, fn, scope) {
				if (Firebird.isEmpty(object)) {
					return;
				}

				if (scope === undefined) {
					scope = object;
				}

				if (Firebird.isIterable(object)) {
					Firebird.Array.each.call(Firebird.Array, object, fn, scope);
				}
				else {
					Firebird.Object.each.call(Firebird.Object, object, fn, scope);
				}
			}
		});

		Firebird.apply(Firebird, {
			/**
			 * 此方法不赞成使用. 请使用 {@link Firebird#define Firebird.define} .
			 * @method
			 * @param {Function} superclass
			 * @param {Object} overrides
			 * @return {Function} The subclass constructor from the <tt>overrides</tt> parameter, or a generated one if not provided.
			 * @deprecated 4.0.0 Use {@link Firebird#define Firebird.define} instead
			 */
			extend: (function () {
				// inline overrides
				var objectConstructor = objectPrototype.constructor,
					inlineOverrides = function (o) {
						for (var m in o) {
							if (!o.hasOwnProperty(m)) {
								continue;
							}
							this[m] = o[m];
						}
					};

				return function (subclass, superclass, overrides) {
					// First we check if the user passed in just the superClass with overrides
					if (Firebird.isObject(superclass)) {
						overrides = superclass;
						superclass = subclass;
						subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function () {
							superclass.apply(this, arguments);
						};
					}

					if (!superclass) {
						firebird.error({
							sourceClass: 'Firebird',
							sourceMethod: 'extend',
							msg: '尝试继承一个未加载的类'
						});
					}

					// We create a new temporary class
					var F = function () {
						},
						subclassProto, superclassProto = superclass.prototype;

					F.prototype = superclassProto;
					subclassProto = subclass.prototype = new F();
					subclassProto.constructor = subclass;
					subclass.superclass = superclassProto;

					if (superclassProto.constructor === objectConstructor) {
						superclassProto.constructor = superclass;
					}

					subclass.override = function (overrides) {
						Firebird.override(subclass, overrides);
					};

					subclassProto.override = inlineOverrides;
					subclassProto.proto = subclassProto;

					subclass.override(overrides);
					subclass.extend = function (o) {
						return Firebird.extend(subclass, o);
					};

					return subclass;
				};
			}()),
			/**
			 * 重写目标成员使用给定的值
			 *
			 * 如果这个目标成员是使用 {@link Firebird#define Firebird.define} 声明的，
			 * 那么这个成员方法会调用新的方法 (see {@link Firebird.Base#override})
			 * If the `target` is a class declared using {@link Firebird#define Firebird.define}, the
			 * `override` method of that class is called  given
			 * the `overrides`.
			 *
			 * If the `target` is a function, it is assumed to be a constructor and the contents
			 * of `overrides` are applied to its `prototype` using {@link Firebird#apply Firebird.apply}.
			 *
			 * If the `target` is an instance of a class declared using {@link Firebird#define Firebird.define},
			 * the `overrides` are applied to only that instance. In this case, methods are
			 * specially processed to allow them to use {@link Firebird.Base#callParent}.
			 *
			 *      var panel = new Firebird.Panel({ ... });
			 *
			 *      Firebird.override(panel, {
             *          initComponent: function () {
             *              // extra processing...
             *
             *              this.callParent();
             *          }
             *      });
			 *
			 * If the `target` is none of these, the `overrides` are applied to the `target`
			 * using {@link Firebird#apply Firebird.apply}.
			 *
			 * Please refer to {@link Firebird#define Firebird.define} and {@link Firebird.Base#override} for
			 * further details.
			 *
			 * @param {Object} target The target to override.
			 * @param {Object} overrides The properties to add or replace on `target`.
			 * @method override
			 */
			override: function (target, overrides) {
				if (target.$isClass) {
					target.override(overrides);
				} else if (typeof target == 'function') {
					Firebird.apply(target.prototype, overrides);
				} else {
					var owner = target.self,
						name, value;

					if (owner && owner.$isClass) { // if (instance of Firebird.define'd class)
						for (name in overrides) {
							if (overrides.hasOwnProperty(name)) {
								value = overrides[name];

								if (typeof value == 'function') {
									if (owner.$className) {
										value.displayName = owner.$className + '#' + name;
									}

									value.$name = name;
									value.$owner = owner;
									value.$previous = target.hasOwnProperty(name)
										? target[name] // already hooked, so call previous hook
										: callOverrideParent; // calls by name on prototype
								}

								target[name] = value;
							}
						}
					} else {
						Firebird.apply(target, overrides);
					}
				}

				return target;
			}
		});

		// 一个用于检查类型的静态方法集合
		Firebird.apply(Firebird, {
			/**
			 * Returns the given value itself if it's not empty, as described in {@link Firebird#isEmpty}; returns the default
			 * value (second argument) otherwise.
			 *
			 * @param {Object} value The value to test
			 * @param {Object} defaultValue The value to return if the original value is empty
			 * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
			 * @return {Object} value, if non-empty, else defaultValue
			 */
			valueFrom: function (value, defaultValue, allowBlank) {
				return Firebird.isEmpty(value, allowBlank) ? defaultValue : value;
			},
			/**
			 * 返回的类型名称，注意，返回的值都是字符串类型。
			 * 以下是返回值的列表
			 * - `undefined`: If the given value is `undefined`
			 * - `null`: If the given value is `null`
			 * - `string`: If the given value is a string
			 * - `number`: If the given value is a number
			 * - `boolean`: If the given value is a boolean value
			 * - `date`: If the given value is a `Date` object
			 * - `function`: If the given value is a function reference
			 * - `object`: If the given value is an object
			 * - `array`: If the given value is an array
			 * - `regexp`: If the given value is a regular expression
			 * - `element`: If the given value is a DOM Element
			 * - `textnode`: If the given value is a DOM text node and contains something other than whitespace
			 * - `whitespace`: If the given value is a DOM text node and contains only whitespace
			 *
			 * @param {Object} value
			 * @return {String}
			 * @markdown
			 */
			typeOf: function (value) {
				var type,
					typeToString;

				if (value === null) {
					return 'null';
				}

				type = typeof value;

				if (type === 'undefined' || type === 'string' || type === 'number' || type === 'boolean') {
					return type;
				}

				typeToString = toString.call(value);

				switch (typeToString) {
					case '[object Array]':
						return 'array';
					case '[object Date]':
						return 'date';
					case '[object Boolean]':
						return 'boolean';
					case '[object Number]':
						return 'number';
					case '[object RegExp]':
						return 'regexp';
				}

				if (type === 'function') {
					return 'function';
				}

				if (type === 'object') {
					if (value.nodeType !== undefined) {
						if (value.nodeType === 3) {
							return (nonWhitespaceRe).test(value.nodeValue) ? 'textnode' : 'whitespace';
						}
						else {
							return 'element';
						}
					}

					return 'object';
				}

				firebird.error("Firebird.typeOf 方法检查数据类型失败，这个可能是个BUG.");

//                firebird.error({
//                    sourceClass: 'Firebird',
//                    sourceMethod: 'typeOf',
//                    msg: 'Failed to determine the type of the specified value "' + value + '". This is most likely a bug.'
//                });
			},
			/**
			 * 强制数据类型转换
			 * Coerces the first value if possible so that it is comparable to the second value.
			 *
			 * 强制数据类型转换只能在基本类型下使用，如 String, Boolean, Number, Date, null, undefined.
			 *
			 * Numbers and numeric strings are coerced to Dates using the value as the millisecond era value.
			 *
			 * Strings are coerced to Dates by parsing using the {@link Firebird.Date#defaultFormat defaultFormat}.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.coerce('false', true);
			 * // false
			 *
			 * Firebird.coerce("123456.1", 2);
			 * // 123456.1
			 *
			 * 对于时间类型较为特殊
			 * Firebird.coerce(new Date, 2);
			 * // 1400141209826
			 * Firebird.coerce(new Date, "a");
			 * // "Thu May 15 2014 16:06:57 GMT+0800 (CST)"
			 * Firebird.coerce(new Date, new Date);
			 * // Thu May 15 2014 16:07:19 GMT+0800 (CST)
			 * Firebird.coerce(1400141211790, '');
			 * // "1400141211790"
			 * Firebird.coerce(1400141211790, new Date);
			 * // "Thu May 15 2014 16:07:47 GMT+0800 (CST)"
			 *
			 * returns the boolean value `false` because the second parameter is of type `Boolean`.
			 *        </code>
			 * </pre>
			 *
			 * @param {Mixed} from The value to coerce
			 * @param {Mixed} to The value it must be compared against
			 * @return The coerced value.
			 */
			coerce: function (from, to) {
				var fromType = Firebird.typeOf(from),
					toType = Firebird.typeOf(to),
					isString = typeof from === 'string';

				if (fromType !== toType) {
					switch (toType) {
						case 'string':
							return String(from);
						case 'number':
							return Number(from);
						case 'boolean':
							return isString && (!from || from === 'false') ? false : Boolean(from);
						case 'null':
							return isString && (!from || from === 'null') ? null : from;
						case 'undefined':
							return isString && (!from || from === 'undefined') ? undefined : from;
						case 'date':
							return isString && isNaN(from) ? Firebird.Date.parse(from, Firebird.Date.defaultFormat) : Date(Number(from));
					}
				}
				return from;
			},
			/**
			 * 检查值是否为空，如果为空返回 true，其余返回 false。
			 * The value is deemed to be empty if it is either:
			 *
			 * - `null`
			 * - `undefined`
			 * - a zero-length array
			 * - a zero-length string (Unless the `allowEmptyString` parameter is set to `true`)
			 *
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.isEmpty(null)
			 * // true
			 * Firebird.isEmpty(undefined)
			 * // true
			 * Firebird.isEmpty(new Array(0))
			 * // true
			 * Firebird.isEmpty(new Array(1))
			 * // false
			 * Firebird.isEmpty('')
			 * // true
			 * Firebird.isEmpty([])
			 * // true
			 *        </code>
			 * </pre>
			 * @param {Object} value The value to test
			 * @param {Boolean} allowEmptyString (optional) true to allow empty strings (defaults to false)
			 * @return {Boolean}
			 * @markdown
			 */
			isEmpty: function (value, allowEmptyString) {
				return (value === null) || (value === undefined) || (!allowEmptyString ? value === '' : false) || (Firebird.isArray(value) && value.length === 0);
			},
			/**
			 * 测试目标值是否为一个 JavaScript 数组，如果是则返回 true，其余返回 false。
			 *
			 * @param {Object} target The target to test
			 * @return {Boolean}
			 * @method
			 */
			isArray: ('isArray' in Array) ? Array.isArray : function (value) {
				return toString.call(value) === '[object Array]';
			},
			/**
			 * 测试目标值是否为一个 JavaScript 日期对象，如果是则返回 true，其余返回 false。
			 * @param {Object} object The object to test
			 * @return {Boolean}
			 */
			isDate: function (value) {
				return toString.call(value) === '[object Date]';
			},
			/**
			 * 测试目标值是否为一个 JavaScript 对象，如果是则返回 true，其余返回 false。
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 * @method
			 */
			isObject: (toString.call(null) === '[object Object]') ?
				function (value) {
					// check ownerDocument here as well to exclude DOM nodes
					return value !== null && value !== undefined && toString.call(value) === '[object Object]' && value.ownerDocument === undefined;
				} :
				function (value) {
					return toString.call(value) === '[object Object]';
				},
			/**
			 * @private
			 */
			isSimpleObject: function (value) {
				return value instanceof Object && value.constructor === Object;
			},
			/**
			 * 测试目标值是否为一个 JavaScript 基本类型，如果是则返回 true，其余返回 false。
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isPrimitive: function (value) {
				var type = typeof value;

				return type === 'string' || type === 'number' || type === 'boolean';
			},
			/**
			 * 测试目标值是否为一个 JavaScript 函数，如果是则返回 true，其余返回 false。
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 * @method
			 */
			isFunction: function (value) {
				return !!(value && value.$extIsFunction);
			},
			/**
			 * 测试目标值是否为一个 JavaScript 有限的数值，如果是则返回 true，其余返回 false。
			 * 请注意，是有限的。
			 * Returns true if the passed value is a number. Returns false for non-finite numbers.
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isNumber: function (value) {
				return typeof value === 'number' && isFinite(value);
			},
			/**
			 * 测试目标值是否为一个 JavaScript 有限的数值，如果是则返回 true，其余返回 false。
			 * @param {Object} value Examples: 1, '1', '2.34'
			 * @return {Boolean} True if numeric, false otherwise
			 */
			isNumeric: function (value) {
				return !isNaN(parseFloat(value)) && isFinite(value);
			},
			/**
			 * Returns true if the passed value is a string.
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isString: function (value) {
				return typeof value === 'string';
			},
			/**
			 * Returns true if the passed value is a boolean.
			 *
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isBoolean: function (value) {
				return typeof value === 'boolean';
			},
			/**
			 * Returns true if the passed value is an HTMLElement
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isElement: function (value) {
				return value ? value.nodeType === 1 : false;
			},
			/**
			 * Returns true if the passed value is a TextNode
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isTextNode: function (value) {
				return value ? value.nodeName === "#text" : false;
			},
			/**
			 * Returns true if the passed value is defined.
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isDefined: function (value) {
				return typeof value !== 'undefined';
			},
			/**
			 * Returns `true` if the passed value is iterable, that is, if elements of it are addressable using array
			 * notation with numeric indices, `false` otherwise.
			 *
			 * Arrays and function `arguments` objects are iterable. Also HTML collections such as `NodeList` and `HTMLCollection'
			 * are iterable.
			 *
			 * @param {Object} value The value to test
			 * @return {Boolean}
			 */
			isIterable: function (value) {
				// To be iterable, the object must have a numeric length property and must not be a string or function.
				if (!value || typeof value.length !== 'number' || typeof value === 'string' || value.$extIsFunction) {
					return false;
				}

				// Certain "standard" collections in IE (such as document.images) do not offer the correct
				// Javascript Object interface; specifically, they lack the propertyIsEnumerable method.
				// And the item property while it does exist is not typeof "function"
				if (!value.propertyIsEnumerable) {
					return !!value.item;
				}

				// If it is a regular, interrogatable JS object (not an IE ActiveX object), then...
				// If it has its own property called "length", but not enumerable, it's iterable
				if (value.hasOwnProperty('length') && !value.propertyIsEnumerable('length')) {
					return true;
				}

				// Test against whitelist which includes known iterable collection types
				return iterableRe.test(toString.call(value));
			}
		});

		Firebird.apply(Firebird, {
			/**
			 * Clone simple variables including array, {}-like objects, DOM nodes and Date without keeping the old reference.
			 * A reference for the object itself is returned if it's not a direct decendant of Object. For model cloning,
			 * see {@link Firebird.data.Model#copy Model.copy}.
			 *
			 * @param {Object} item The variable to clone
			 * @return {Object} clone
			 */
			clone: function (item) {
				var type,
					i,
					j,
					k,
					clone,
					key;

				if (item === null || item === undefined) {
					return item;
				}

				// DOM nodes
				// TODO proxy this to Firebird.Element.clone to handle automatic id attribute changing
				// recursively
				if (item.nodeType && item.cloneNode) {
					return item.cloneNode(true);
				}

				type = toString.call(item);

				// Date
				if (type === '[object Date]') {
					return new Date(item.getTime());
				}

				// Array
				if (type === '[object Array]') {
					i = item.length;

					clone = [];

					while (i--) {
						clone[i] = Firebird.clone(item[i]);
					}
				}
				// Object
				else if (type === '[object Object]' && item.constructor === Object) {
					clone = {};

					for (key in item) {
						clone[key] = Firebird.clone(item[key]);
					}

					if (enumerables) {
						for (j = enumerables.length; j--;) {
							k = enumerables[j];
							if (item.hasOwnProperty(k)) {
								clone[k] = item[k];
							}
						}
					}
				}

				return clone || item;
			},
			/**
			 * @private
			 * Generate a unique reference of Firebird in the global scope, useful for sandboxing
			 */
			getUniqueGlobalNamespace: function () {
				var uniqueGlobalNamespace = this.uniqueGlobalNamespace,
					i;

				if (uniqueGlobalNamespace === undefined) {
					i = 0;

					do {
						uniqueGlobalNamespace = 'FirebirdBox' + (++i);
					} while (Firebird.global[uniqueGlobalNamespace] !== undefined);

					Firebird.global[uniqueGlobalNamespace] = Firebird;
					this.uniqueGlobalNamespace = uniqueGlobalNamespace;
				}

				return uniqueGlobalNamespace;
			},
			/**
			 * @private
			 */
			functionFactoryCache: {},
			cacheableFunctionFactory: function () {
				var me = this,
					args = Array.prototype.slice.call(arguments),
					cache = me.functionFactoryCache,
					idx, fn, ln;

				if (Firebird.isSandboxed) {
					ln = args.length;
					if (ln > 0) {
						ln--;
						args[ln] = 'var Firebird=window.' + Firebird.name + ';' + args[ln];
					}
				}
				idx = args.join('');
				fn = cache[idx];
				if (!fn) {
					fn = Function.prototype.constructor.apply(Function.prototype, args);

					cache[idx] = fn;
				}
				return fn;
			},
			functionFactory: function () {
				var me = this,
					args = Array.prototype.slice.call(arguments),
					ln;

				if (Firebird.isSandboxed) {
					ln = args.length;
					if (ln > 0) {
						ln--;
						args[ln] = 'var Firebird=window.' + Firebird.name + ';' + args[ln];
					}
				}

				return Function.prototype.constructor.apply(Function.prototype, args);
			},
			/**
			 * @private
			 * @property
			 */
			Logger: {
				verbose: emptyFn,
				log: emptyFn,
				info: emptyFn,
				warn: emptyFn,
				error: function (message) {
					firebird.error(new Error(message));
				},
				deprecate: emptyFn
			}
		});

		/**
		 * 旧的别名 {@link Firebird#typeOf}
		 * @deprecated 4.0.0 Use {@link Firebird#typeOf} instead
		 * @method
		 * @inheritdoc Firebird#typeOf
		 */
		Firebird.type = Firebird.typeOf;

		// When using Cmd optimizations, the namespace Firebird.app may already be defined
		// by this point since it's done up front by the tool. Check if app already
		// exists before overwriting it.
		FirebirdApp = Firebird.app;
		if (!FirebirdApp) {
			FirebirdApp = Firebird.app = {};
		}
		Firebird.apply(FirebirdApp, {
			namespaces: {},
			/**
			 * @private
			 */
			collectNamespaces: function (paths) {
				var namespaces = Firebird.app.namespaces,
					path;

				for (path in paths) {
					if (paths.hasOwnProperty(path)) {
						namespaces[path] = true;
					}
				}
			},
			/**
			 * Adds namespace(s) to known list.
			 *
			 * @param {String/String[]} namespace
			 */
			addNamespaces: function (ns) {
				var namespaces = Firebird.app.namespaces,
					i, l;

				if (!Firebird.isArray(ns)) {
					ns = [ns];
				}

				for (i = 0, l = ns.length; i < l; i++) {
					namespaces[ns[i]] = true;
				}
			},
			/**
			 * @private Clear all namespaces from known list.
			 */
			clearNamespaces: function () {
				Firebird.app.namespaces = {};
			},
			/**
			 * Get namespace prefix for a class name.
			 *
			 * @param {String} className
			 *
			 * @return {String} Namespace prefix if it's known, otherwise undefined
			 */
			getNamespace: function (className) {
				var namespaces = Firebird.app.namespaces,
					deepestPrefix = '',
					prefix;

				for (prefix in namespaces) {
					if (namespaces.hasOwnProperty(prefix) &&
						prefix.length > deepestPrefix.length &&
						(prefix + '.' === className.substring(0, prefix.length + 1))) {
						deepestPrefix = prefix;
					}
				}

				return deepestPrefix === '' ? undefined : deepestPrefix;
			}
		});
	}());

	/*
	 * This method evaluates the given code free of any local variable. In some browsers this
	 * will be at global scope, in others it will be in a function.
	 * @parma {String} code The code to evaluate.
	 * @private
	 * @method
	 */
	Firebird.globalEval = Firebird.global.execScript
		? function (code) {
		execScript(code);
	}
		: function ($$code) {
		// IMPORTANT: because we use eval we cannot place this in the above function or it
		// will break the compressor's ability to rename local variables...
		(function () {
			// This var should not be replaced by the compressor. We need to do this so
			// that Firebird refers to the global Firebird, if we're sandboxing it may
			// refer to the local instance inside the closure
			var Firebird = this.Firebird;
			eval($$code);
		}());
	};

// @tag foundation,core
// @require ../Firebird.js
// @define Firebird.Version

	/**
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 * @class Firebird.Version
	 *
	 * A utility class that wrap around a string version number and provide convenient
	 * method to perform comparison. 参见: {@link Firebird.Version#compare compare}. Example:
	 * @example
	 * 例子
	 * <pre>
	 *     <code>
	 *     var version = new Firebird.Version('1.0.2beta');
	 *     console.log("Version is " + version); // Version is 1.0.2beta
	 *
	 *     console.log(version.getMajor()); // 1
	 *     console.log(version.getMinor()); // 0
	 *     console.log(version.getPatch()); // 2
	 *     console.log(version.getBuild()); // 0
	 *     console.log(version.getRelease()); // beta
	 *
	 *     console.log(version.isGreaterThan('1.0.1')); // True
	 *     console.log(version.isGreaterThan('1.0.2alpha')); // True
	 *     console.log(version.isGreaterThan('1.0.2RC')); // False
	 *     console.log(version.isGreaterThan('1.0.2')); // False
	 *     console.log(version.isLessThan('1.0.2')); // True
	 *
	 *     console.log(version.match(1.0)); // True
	 *     console.log(version.match('1.0.2')); // True
	 *        </code>
	 * </pre>
	 */
// 	(function () {
//
// // Current core version
// // also fix Firebir-more.js
// 		var version = '4.2.1.883', Version;
// 		Firebird.Version = Version = Firebird.extend(Object, {
// 			/**
// 			 * @param {String/Number} version The version number in the following standard format:
// 			 *
// 			 *     major[.minor[.patch[.build[release]]]]
// 			 *
// 			 * // Examples:
// 			 *
// 			 *     1.0
// 			 *     1.2.3beta
// 			 *     1.2.3.4RC
// 			 *
// 			 * @return {Firebird.Version} this
// 			 */
// 			constructor: function (version) {
// 				var parts, releaseStartIndex;
//
// 				if (version instanceof Version) {
// 					return version;
// 				}
//
// 				this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
//
// 				releaseStartIndex = this.version.search(/([^\d\.])/);
//
// 				if (releaseStartIndex !== -1) {
// 					this.release = this.version.substr(releaseStartIndex, version.length);
// 					this.shortVersion = this.version.substr(0, releaseStartIndex);
// 				}
//
// 				this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
//
// 				parts = this.version.split('.');
//
// 				this.major = parseInt(parts.shift() || 0, 10);
// 				this.minor = parseInt(parts.shift() || 0, 10);
// 				this.patch = parseInt(parts.shift() || 0, 10);
// 				this.build = parseInt(parts.shift() || 0, 10);
//
// 				return this;
// 			},
// 			/**
// 			 * Override the native toString method
// 			 * @private
// 			 * @return {String} version
// 			 */
// 			toString: function () {
// 				return this.version;
// 			},
// 			/**
// 			 * Override the native valueOf method
// 			 * @private
// 			 * @return {String} version
// 			 */
// 			valueOf: function () {
// 				return this.version;
// 			},
// 			/**
// 			 * Returns the major component value
// 			 * @return {Number} major
// 			 */
// 			getMajor: function () {
// 				return this.major || 0;
// 			},
// 			/**
// 			 * Returns the minor component value
// 			 * @return {Number} minor
// 			 */
// 			getMinor: function () {
// 				return this.minor || 0;
// 			},
// 			/**
// 			 * Returns the patch component value
// 			 * @return {Number} patch
// 			 */
// 			getPatch: function () {
// 				return this.patch || 0;
// 			},
// 			/**
// 			 * Returns the build component value
// 			 * @return {Number} build
// 			 */
// 			getBuild: function () {
// 				return this.build || 0;
// 			},
// 			/**
// 			 * Returns the release component value
// 			 * @return {Number} release
// 			 */
// 			getRelease: function () {
// 				return this.release || '';
// 			},
// 			/**
// 			 * Returns whether this version if greater than the supplied argument
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version if greater than the target, false otherwise
// 			 */
// 			isGreaterThan: function (target) {
// 				return Version.compare(this.version, target) === 1;
// 			},
// 			/**
// 			 * Returns whether this version if greater than or equal to the supplied argument
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version if greater than or equal to the target, false otherwise
// 			 */
// 			isGreaterThanOrEqual: function (target) {
// 				return Version.compare(this.version, target) >= 0;
// 			},
// 			/**
// 			 * Returns whether this version if smaller than the supplied argument
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version if smaller than the target, false otherwise
// 			 */
// 			isLessThan: function (target) {
// 				return Version.compare(this.version, target) === -1;
// 			},
// 			/**
// 			 * Returns whether this version if less than or equal to the supplied argument
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version if less than or equal to the target, false otherwise
// 			 */
// 			isLessThanOrEqual: function (target) {
// 				return Version.compare(this.version, target) <= 0;
// 			},
// 			/**
// 			 * Returns whether this version equals to the supplied argument
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version equals to the target, false otherwise
// 			 */
// 			equals: function (target) {
// 				return Version.compare(this.version, target) === 0;
// 			},
// 			/**
// 			 * Returns whether this version matches the supplied argument. Example:
// 			 *
// 			 *     var version = new Firebird.Version('1.0.2beta');
// 			 *     console.log(version.match(1)); // True
// 			 *     console.log(version.match(1.0)); // True
// 			 *     console.log(version.match('1.0.2')); // True
// 			 *     console.log(version.match('1.0.2RC')); // False
// 			 *
// 			 * @param {String/Number} target The version to compare with
// 			 * @return {Boolean} True if this version matches the target, false otherwise
// 			 */
// 			match: function (target) {
// 				target = String(target);
// 				return this.version.substr(0, target.length) === target;
// 			},
// 			/**
// 			 * Returns this format: [major, minor, patch, build, release]. Useful for comparison
// 			 * @return {Number[]}
// 			 */
// 			toArray: function () {
// 				return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
// 			},
// 			/**
// 			 * Returns shortVersion version without dots and release
// 			 * @return {String}
// 			 */
// 			getShortVersion: function () {
// 				return this.shortVersion;
// 			},
// 			/**
// 			 * Convenient alias to {@link Firebird.Version#isGreaterThan isGreaterThan}
// 			 * @param {String/Number} target
// 			 * @return {Boolean}
// 			 */
// 			gt: function () {
// 				return this.isGreaterThan.apply(this, arguments);
// 			},
// 			/**
// 			 * Convenient alias to {@link Firebird.Version#isLessThan isLessThan}
// 			 * @param {String/Number} target
// 			 * @return {Boolean}
// 			 */
// 			lt: function () {
// 				return this.isLessThan.apply(this, arguments);
// 			},
// 			/**
// 			 * Convenient alias to {@link Firebird.Version#isGreaterThanOrEqual isGreaterThanOrEqual}
// 			 * @param {String/Number} target
// 			 * @return {Boolean}
// 			 */
// 			gtEq: function () {
// 				return this.isGreaterThanOrEqual.apply(this, arguments);
// 			},
// 			/**
// 			 * Convenient alias to {@link Firebird.Version#isLessThanOrEqual isLessThanOrEqual}
// 			 * @param {String/Number} target
// 			 * @return {Boolean}
// 			 */
// 			ltEq: function () {
// 				return this.isLessThanOrEqual.apply(this, arguments);
// 			}
// 		});
//
// 		Firebird.apply(Version, {
// 			// @private
// 			releaseValueMap: {
// 				'dev': -6,
// 				'alpha': -5,
// 				'a': -5,
// 				'beta': -4,
// 				'b': -4,
// 				'rc': -3,
// 				'#': -2,
// 				'p': -1,
// 				'pl': -1
// 			},
// 			/**
// 			 * Converts a version component to a comparable value
// 			 *
// 			 * @static
// 			 * @param {Object} value The value to convert
// 			 * @return {Object}
// 			 */
// 			getComponentValue: function (value) {
// 				return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
// 			},
// 			/**
// 			 * Compare 2 specified versions, starting from left to right. If a part contains special version strings,
// 			 * they are handled in the following order:
// 			 * 'dev' < 'alpha' = 'a' < 'beta' = 'b' < 'RC' = 'rc' < '#' < 'pl' = 'p' < 'anything else'
// 			 *
// 			 * @static
// 			 * @param {String} current The current version to compare to
// 			 * @param {String} target The target version to compare to
// 			 * @return {Number} Returns -1 if the current version is smaller than the target version, 1 if greater, and 0 if they're equivalent
// 			 */
// 			compare: function (current, target) {
// 				var currentValue, targetValue, i;
//
// 				current = new Version(current).toArray();
// 				target = new Version(target).toArray();
//
// 				for (i = 0; i < Math.max(current.length, target.length); i++) {
// 					currentValue = this.getComponentValue(current[i]);
// 					targetValue = this.getComponentValue(target[i]);
//
// 					if (currentValue < targetValue) {
// 						return -1;
// 					} else if (currentValue > targetValue) {
// 						return 1;
// 					}
// 				}
//
// 				return 0;
// 			}
// 		});
//
// 		/**
// 		 * @class Firebird
// 		 */
// 		Firebird.apply(Firebird, {
// 			/**
// 			 * @private
// 			 */
// 			versions: {},
// 			/**
// 			 * @private
// 			 */
// 			lastRegisteredVersion: null,
// 			/**
// 			 * Set version number for the given package name.
// 			 *
// 			 * @param {String} packageName The package name, for example: 'core', 'touch', 'extjs'
// 			 * @param {String/Firebird.Version} version The version, for example: '1.2.3alpha', '2.4.0-dev'
// 			 * @return {Firebird}
// 			 */
// 			setVersion: function (packageName, version) {
// 				Firebird.versions[packageName] = new Version(version);
// 				Firebird.lastRegisteredVersion = Firebird.versions[packageName];
//
// 				return this;
// 			},
// 			/**
// 			 * Get the version number of the supplied package name; will return the last registered version
// 			 * (last Firebird.setVersion call) if there's no package name given.
// 			 *
// 			 * @param {String} packageName (Optional) The package name, for example: 'core', 'touch', 'extjs'
// 			 * @return {Firebird.Version} The version
// 			 */
// 			getVersion: function (packageName) {
// 				if (packageName === undefined) {
// 					return Firebird.lastRegisteredVersion;
// 				}
//
// 				return Firebird.versions[packageName];
// 			},
// 			/**
// 			 * Create a closure for deprecated code.
// 			 *
// 			 *     // This means Firebird.oldMethod is only supported in 4.0.0beta and older.
// 			 *     // If Firebird.getVersion('extjs') returns a version that is later than '4.0.0beta', for example '4.0.0RC',
// 			 *     // the closure will not be invoked
// 			 *     Firebird.deprecate('extjs', '4.0.0beta', function() {
//              *         Firebird.oldMethod = Firebird.newMethod;
//              *
//              *         ...
//              *     });
// 			 *
// 			 * @param {String} packageName The package name
// 			 * @param {String} since The last version before it's deprecated
// 			 * @param {Function} closure The callback function to be executed with the specified version is less than the current version
// 			 * @param {Object} scope The execution scope (`this`) if the closure
// 			 */
// 			deprecate: function (packageName, since, closure, scope) {
// 				if (Version.compare(Firebird.getVersion(packageName), since) < 1) {
// 					closure.call(scope);
// 				}
// 			}
// 		}); // End Versioning
//
// 		Firebird.setVersion('core', version);
//
// 	}());

// @tag foundation,core
// @require ../version/Version.js
// @define Firebird.String

	/**
	 * @class Firebird.String
	 *
	 * 一个处理字符串的静态方法集合.
	 * @singleton
	 */
	Firebird.String = (function () {
		var trimRegex = /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
			escapeRe = /('|\\)/g,
			formatRe = /\{(\d+)\}/g,
			escapeRegexRe = /([-.*+?\^${}()|\[\]\/\\])/g,
			basicTrimRe = /^\s+|\s+$/g,
			whitespaceRe = /\s+/,
			varReplace = /(^[^a-z]*|[^\w])/gi,
			charToEntity,
			entityToChar,
			charToEntityRegex,
			entityToCharRegex,
			htmlEncodeReplaceFn = function (match, capture) {
				return charToEntity[capture];
			},
			htmlDecodeReplaceFn = function (match, capture) {
				return (capture in entityToChar) ? entityToChar[capture] : String.fromCharCode(parseInt(capture.substr(2), 10));
			},
			boundsCheck = function (s, other) {
				if (s === null || s === undefined || other === null || other === undefined) {
					return false;
				}

				return other.length <= s.length;
			};

		return {
			/**
			 * 把一个字符串插入到另一个字符串
			 * @param {String} s The original string.
			 * @param {String} value The substring to insert.
			 * @param {Number} index The index to insert the substring. Negative indexes will insert from the end of
			 * the string.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *
			 *     Firebird.String.insert("abcdefg", "h", -1); // abcdefhg
			 *        </code>
			 * </pre>
			 * @return {String} The value with the inserted substring
			 */
			insert: function (s, value, index) {
				if (!s) {
					return value;
				}

				if (!value) {
					return s;
				}

				var len = s.length;

				if (!index && index !== 0) {
					index = len;
				}

				if (index < 0) {
					index *= -1;
					if (index >= len) {
						// negative overflow, insert at start
						index = 0;
					} else {
						index = len - index;
					}
				}

				if (index === 0) {
					s = value + s;
				} else if (index >= s.length) {
					s += value;
				} else {
					s = s.substr(0, index) + value + s.substr(index);
				}
				return s;
			},
			/**
			 * 检查一个字符串的是否从某个字符串起始
			 *
			 * @param {String} s The original string
			 * @param {String} start The substring to check
			 * @param {Boolean} [ignoreCase=false] True to ignore the case in the comparison
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.String.startsWith("abcdef", "a")
			 * // true
			 * Firebird.String.startsWith("abcdef", "A")
			 * // false
			 * Firebird.String.startsWith("abcdef", "A", true)
			 * // true
			 * Firebird.String.startsWith("abcdef", "AbC", true)
			 * // true
			 *        </code>
			 * </pre>
			 */
			startsWith: function (s, start, ignoreCase) {
				var result = boundsCheck(s, start);

				if (result) {
					if (ignoreCase) {
						s = s.toLowerCase();
						start = start.toLowerCase();
					}
					result = s.lastIndexOf(start, 0) === 0;
				}
				return result;
			},
			/**
			 * 检查一个字符串的是否从某个字符串结束
			 *
			 * @param {String} s The original string
			 * @param {String} start The substring to check
			 * @param {Boolean} [ignoreCase=false] True to ignore the case in the comparison
			 */
			endsWith: function (s, end, ignoreCase) {
				var result = boundsCheck(s, end);

				if (result) {
					if (ignoreCase) {
						s = s.toLowerCase();
						end = end.toLowerCase();
					}
					result = s.indexOf(end, s.length - end.length) !== -1;
				}
				return result;
			},
			/**
			 * 把字符串转换成一个合法的可以var的名称
			 * 如 var a)&^b = ""; 是错误的。
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.String.createVarName("a)&^b")
			 * // "ab" 这样就可以了。
			 *        </code>
			 * </pre>
			 * Converts a string of characters into a legal, parse-able JavaScript `var` name as long as the passed
			 * string contains at least one alphabetic character. Non alphanumeric characters, and *leading* non alphabetic
			 * characters will be removed.
			 * @param {String} s A string to be converted into a `var` name.
			 * @return {String} A legal JavaScript `var` name.
			 */
			createVarName: function (s) {
				return s.replace(varReplace, '');
			},
			/**
			 * 把HTML代码安全转义
			 * Convert certain characters (&, <, >, ', and ") to their HTML character equivalents for literal display in web pages.
			 * @param {String} value The string to encode.
			 * @return {String} The encoded text.
			 * @method
			 */
			htmlEncode: function (value) {
				return (!value) ? value : String(value).replace(charToEntityRegex, htmlEncodeReplaceFn);
			},
			/**
			 * 把字符串转义为HTML代码
			 * Convert certain characters (&, <, >, ', and ") from their HTML character equivalents.
			 * @param {String} value The string to decode.
			 * @return {String} The decoded text.
			 * @method
			 */
			htmlDecode: function (value) {
				return (!value) ? value : String(value).replace(entityToCharRegex, htmlDecodeReplaceFn);
			},
			/**
			 * 添加新的对照表至html转义符对照表
			 * {@link Firebird.String#htmlEncode} and {@link Firebird.String#htmlDecode}.
			 *
			 * This object should be keyed by the entity name sequence,
			 * with the value being the textual representation of the entity.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *      Firebird.String.addCharacterEntities({
             *          '&amp;Uuml;':'Ü',
             *          '&amp;ccedil;':'ç',
             *          '&amp;ntilde;':'ñ',
             *          '&amp;egrave;':'è'
             *      });
			 *      var s = Firebird.String.htmlEncode("A string with entities: èÜçñ");
			 *        </code>
			 * </pre>
			 * __Note:__ the values of the character entities defined on this object are expected
			 * to be single character values.  As such, the actual values represented by the
			 * characters are sensitive to the character encoding of the JavaScript source
			 * file when defined in string literal form. Script tags referencing server
			 * resources with character entities must ensure that the 'charset' attribute
			 * of the script node is consistent with the actual character encoding of the
			 * server resource.
			 *
			 * The set of character entities may be reset back to the default state by using
			 * the {@link Firebird.String#resetCharacterEntities} method
			 *
			 * @param {Object} entities The set of character entities to add to the current
			 * definitions.
			 */
			addCharacterEntities: function (newEntities) {
				var charKeys = [],
					entityKeys = [],
					key, echar;
				for (key in newEntities) {
					echar = newEntities[key];
					entityToChar[key] = echar;
					charToEntity[echar] = key;
					charKeys.push(echar);
					entityKeys.push(key);
				}
				charToEntityRegex = new RegExp('(' + charKeys.join('|') + ')', 'g');
				entityToCharRegex = new RegExp('(' + entityKeys.join('|') + '|&#[0-9]{1,5};' + ')', 'g');
			},
			/**
			 * 把html转义符对照表重置到默认状态
			 * {@link Firebird.String#htmlEncode} and {@link Firebird.String#htmlDecode} back to the
			 * default state.
			 */
			resetCharacterEntities: function () {
				charToEntity = {};
				entityToChar = {};
				// add the default set
				this.addCharacterEntities({
					'&amp;': '&',
					'&gt;': '>',
					'&lt;': '<',
					'&quot;': '"',
					'&#39;': "'"
				});
			},
			/**
			 * 追加字符串到一个地址字符串之后，此方法会自动处理参数逻辑，指 ?, &。
			 * Appends content to the query string of a URL, handling logic for whether to place
			 * a question mark or ampersand.
			 * @param {String} url The URL to append to.
			 * @param {String} string The content to append to the URL.
			 * @return {String} The resulting URL
			 */
			urlAppend: function (url, string) {
				if (!Firebird.isEmpty(string)) {
					return url + (url.indexOf('?') === -1 ? '?' : '&') + string;
				}

				return url;
			},
			/**
			 * 去除字符串两侧的空白
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *
			 *     var s = '  foo bar  ';
			 *     alert('-' + s + '-');
			 *     // alerts "- foo bar -"
			 *     alert('-' + Firebird.String.trim(s) + '-');
			 *     // alerts "-foo bar-"
			 *        </code>
			 * </pre>
			 * @param {String} string The string to trim.
			 * @return {String} The trimmed string.
			 */
			trim: function (string) {
				return string.replace(trimRegex, "");
			},
			/**
			 * 把字符串进行驼峰化处理
			 * @param {String} string
			 * @return {String}
			 */
			capitalize: function (string) {
				return string.charAt(0).toUpperCase() + string.substr(1);
			},
			/**
			 * 把字符串进行去驼峰化处理
			 * @param {String} string
			 * @return {String}
			 */
			uncapitalize: function (string) {
				return string.charAt(0).toLowerCase() + string.substr(1);
			},
			/**
			 * 截断一个字符串并加上省略号
			 * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length.
			 * @param {String} value The string to truncate.
			 * @param {Number} length The maximum length to allow before truncating.
			 * @param {Boolean} [word=false] `true` to try to find a common word break.
			 * @return {String} The converted text.
			 */
			ellipsis: function (value, len, word) {
				if (value && value.length > len) {
					if (word) {
						var vs = value.substr(0, len - 2),
							index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
						if (index !== -1 && index >= (len - 15)) {
							return vs.substr(0, index) + "...";
						}
					}
					return value.substr(0, len - 3) + "...";
				}
				return value;
			},
			/**
			 * Escapes the passed string for use in a regular expression.
			 * @param {String} string
			 * @return {String}
			 */
			escapeRegex: function (string) {
				return string.replace(escapeRegexRe, "\\$1");
			},
			/**
			 * Escapes the passed string for ' and \
			 * @param {String} string The string to escape
			 * @return {String} The escaped string
			 */
			escape: function (string) {
				return string.replace(escapeRe, "\\$1");
			},
			/**
			 * Utility function that allows you to easily switch a string between two alternating values.  The passed value
			 * is compared to the current string, and if they are equal, the other value that was passed in is returned.  If
			 * they are already different, the first value passed in is returned.  Note that this method returns the new value
			 * but does not change the current string.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *     // alternate sort directions
			 *     sort = Firebird.String.toggle(sort, 'ASC', 'DESC');
			 *
			 *     // instead of conditional logic:
			 *     sort = (sort === 'ASC' ? 'DESC' : 'ASC');
			 *        </code>
			 * </pre>
			 * @param {String} string The current string.
			 * @param {String} value The value to compare to the current string.
			 * @param {String} other The new value to use if the string already equals the first value passed in.
			 * @return {String} The new value.
			 */
			toggle: function (string, value, other) {
				return string === value ? other : value;
			},
			/**
			 * 补足字符串长度
			 * Pads the left side of a string with a specified character.  This is especially useful
			 * for normalizing number and date strings.  Example usage:
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *         var s = Firebird.String.leftPad('123', 5, '0');
			 *         // s now contains the string: '00123'
			 *     </code>
			 * </pre>
			 * @param {String} string The original string.
			 * @param {Number} size The total length of the output string.
			 * @param {String} [character=' '] (optional) The character with which to pad the original string.
			 * @return {String} The padded string.
			 */
			leftPad: function (string, size, character) {
				var result = String(string);
				character = character || " ";
				while (result.length < size) {
					result = character + result;
				}
				return result;
			},
			/**
			 * 格式化模板
			 * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens.  Each
			 * token must be unique, and must increment in the format {0}, {1}, etc.  Example usage:
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *     var cls = 'my-class',
			 *         text = 'Some text';
			 *     var s = Firebird.String.format('<div class="{0}">{1}</div>', cls, text);
			 *     // s now contains the string: '<div class="my-class">Some text</div>'
			 *        </code>
			 * </pre>
			 * @param {String} string The tokenized string to be formatted.
			 * @param {Mixed...} values The values to replace tokens `{0}`, `{1}`, etc in order.
			 * @return {String} The formatted string.
			 */
			format: function (format) {
				var args = Firebird.Array.toArray(arguments, 1);
				return format.replace(formatRe, function (m, i) {
					return args[i];
				});
			},
			/**
			 * 重复输出一个字符串
			 * Returns a string with a specified number of repetitions a given string pattern.
			 * The pattern be separated by a different string.
			 *
			 *      var s = Firebird.String.repeat('---', 4); // = '------------'
			 *      var t = Firebird.String.repeat('--', 3, '/'); // = '--/--/--'
			 *
			 * @param {String} pattern The pattern to repeat.
			 * @param {Number} count The number of times to repeat the pattern (may be 0).
			 * @param {String} sep An option string to separate each pattern.
			 */
			repeat: function (pattern, count, sep) {
				if (count < 1) {
					count = 0;
				}
				for (var buf = [], i = count; i--;) {
					buf.push(pattern);
				}
				return buf.join(sep || '');
			},
			/**
			 * 分割字符串成数组
			 * Splits a string of space separated words into an array, trimming as needed. If the
			 * words are already an array, it is returned.
			 *
			 * @param {String/Array} words
			 */
			splitWords: function (words) {
				if (words && typeof words == 'string') {
					return words.replace(basicTrimRe, '').split(whitespaceRe);
				}
				return words || [];
			}
		};
	}());

// initialize the default encode / decode entities
	Firebird.String.resetCharacterEntities();

	/**
	 * 别名
	 * Old alias to {@link Firebird.String#htmlEncode}
	 * @deprecated Use {@link Firebird.String#htmlEncode} instead
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.String#htmlEncode
	 */
	Firebird.htmlEncode = Firebird.String.htmlEncode;

	/**
	 * 别名
	 * Old alias to {@link Firebird.String#htmlDecode}
	 * @deprecated Use {@link Firebird.String#htmlDecode} instead
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.String#htmlDecode
	 */
	Firebird.htmlDecode = Firebird.String.htmlDecode;

	/**
	 * 别名
	 * Old alias to {@link Firebird.String#urlAppend}
	 * @deprecated Use {@link Firebird.String#urlAppend} instead
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.String#urlAppend
	 */
	Firebird.urlAppend = Firebird.String.urlAppend;

// @tag foundation,core
// @require String.js
// @define Firebird.Number

	/**
	 * 一些处理数值的静态方法集合
	 *
	 * @class Firebird.Number
	 *
	 * A collection of useful static methods to deal with numbers
	 * @singleton
	 */

	Firebird.Number = new function () {

		var me = this,
			isToFixedBroken = (0.9).toFixed() !== '1',
			math = Math;

		Firebird.apply(this, {
			/**
			 * Checks whether or not the passed number is within a desired range.  If the number is already within the
			 * range it is returned, otherwise the min or max value is returned depending on which side of the range is
			 * exceeded. Note that this method returns the constrained value but does not change the current number.
			 * @param {Number} number The number to check
			 * @param {Number} min The minimum number in the range
			 * @param {Number} max The maximum number in the range
			 * @return {Number} The constrained value if outside the range, otherwise the current value
			 */
			constrain: function (number, min, max) {
				var x = parseFloat(number);

				// Watch out for NaN in Chrome 18
				// V8bug: http://code.google.com/p/v8/issues/detail?id=2056

				// Operators are faster than Math.min/max. See http://jsperf.com/number-constrain
				// ... and (x < Nan) || (x < undefined) == false
				// ... same for (x > NaN) || (x > undefined)
				// so if min or max are undefined or NaN, we never return them... sadly, this
				// is not true of null (but even Math.max(-1,null)==0 and isNaN(null)==false)
				return (x < min) ? min : ((x > max) ? max : x);
			},
			/**
			 * Snaps the passed number between stopping points based upon a passed increment value.
			 *
			 * The difference between this and {@link #snapInRange} is that {@link #snapInRange} uses the minValue
			 * when calculating snap points:
			 *
			 *     r = Firebird.Number.snap(56, 2, 55, 65);        // Returns 56 - snap points are zero based
			 *
			 *     r = Firebird.Number.snapInRange(56, 2, 55, 65); // Returns 57 - snap points are based from minValue
			 *
			 * @param {Number} value The unsnapped value.
			 * @param {Number} increment The increment by which the value must move.
			 * @param {Number} minValue The minimum value to which the returned value must be constrained. Overrides the increment.
			 * @param {Number} maxValue The maximum value to which the returned value must be constrained. Overrides the increment.
			 * @return {Number} The value of the nearest snap target.
			 */
			snap: function (value, increment, minValue, maxValue) {
				var m;

				// If no value passed, or minValue was passed and value is less than minValue (anything < undefined is false)
				// Then use the minValue (or zero if the value was undefined)
				if (value === undefined || value < minValue) {
					return minValue || 0;
				}

				if (increment) {
					m = value % increment;
					if (m !== 0) {
						value -= m;
						if (m * 2 >= increment) {
							value += increment;
						} else if (m * 2 < -increment) {
							value -= increment;
						}
					}
				}
				return me.constrain(value, minValue, maxValue);
			},
			/**
			 * Snaps the passed number between stopping points based upon a passed increment value.
			 *
			 * The difference between this and {@link #snap} is that {@link #snap} does not use the minValue
			 * when calculating snap points:
			 *
			 *     r = Firebird.Number.snap(56, 2, 55, 65);        // Returns 56 - snap points are zero based
			 *
			 *     r = Firebird.Number.snapInRange(56, 2, 55, 65); // Returns 57 - snap points are based from minValue
			 *
			 * @param {Number} value The unsnapped value.
			 * @param {Number} increment The increment by which the value must move.
			 * @param {Number} [minValue=0] The minimum value to which the returned value must be constrained.
			 * @param {Number} [maxValue=Infinity] The maximum value to which the returned value must be constrained.
			 * @return {Number} The value of the nearest snap target.
			 */
			snapInRange: function (value, increment, minValue, maxValue) {
				var tween;

				// default minValue to zero
				minValue = (minValue || 0);

				// If value is undefined, or less than minValue, use minValue
				if (value === undefined || value < minValue) {
					return minValue;
				}

				// Calculate how many snap points from the minValue the passed value is.
				if (increment && (tween = ((value - minValue) % increment))) {
					value -= tween;
					tween *= 2;
					if (tween >= increment) {
						value += increment;
					}
				}

				// If constraining within a maximum, ensure the maximum is on a snap point
				if (maxValue !== undefined) {
					if (value > (maxValue = me.snapInRange(maxValue, increment, minValue))) {
						value = maxValue;
					}
				}

				return value;
			},
			/**
			 * 格式化小数点
			 * Formats a number using fixed-point notation
			 * @param {Number} value The number to format
			 * @param {Number} precision The number of digits to show after the decimal point
			 */
			toFixed: isToFixedBroken ? function (value, precision) {
				precision = precision || 0;
				var pow = math.pow(10, precision);
				return (math.round(value * pow) / pow).toFixed(precision);
			} : function (value, precision) {
				return value.toFixed(precision);
			},
			/**
			 * 校验一个值是否为数值
			 * Validate that a value is numeric and convert it to a number if necessary. Returns the specified default value if
			 * it is not.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *         Firebird.Number.from('1.23', 1); // returns 1.23
			 *         Firebird.Number.from('abc', 1); // returns 1
			 *        </code>
			 * </pre>
			 * @param {Object} value
			 * @param {Number} defaultValue The value to return if the original value is non-numeric
			 * @return {Number} value, if numeric, defaultValue otherwise
			 */
			from: function (value, defaultValue) {
				if (isFinite(value)) {
					value = parseFloat(value);
				}

				return !isNaN(value) ? value : defaultValue;
			},
			/**
			 * 随机返回一个有效区间内的整数
			 * Returns a random integer between the specified range (inclusive)
			 * @param {Number} from Lowest value to return.
			 * @param {Number} to Highst value to return.
			 * @return {Number} A random integer within the specified range.
			 */
			randomInt: function (from, to) {
				return math.floor(math.random() * (to - from + 1) + from);
			},
			/**
			 * Corrects floating point numbers that overflow to a non-precise
			 * value because of their floating nature, for example `0.1 + 0.2`
			 * @param {Number} The number
			 * @return {Number} The correctly rounded number
			 */
			correctFloat: function (n) {
				// This is to correct the type of errors where 2 floats end with
				// a long string of decimals, eg 0.1 + 0.2. When they overflow in this
				// manner, they usually go to 15-16 decimals, so we cut it off at 14.
				return parseFloat(n.toPrecision(14));
			}
		});

		/**
		 * @deprecated 4.0.0 Please use {@link Firebird.Number#from} instead.
		 * @member Firebird
		 * @method num
		 * @inheritdoc Firebird.Number#from
		 */
		Firebird.num = function () {
			return me.from.apply(this, arguments);
		};
	};

// @tag foundation,core
// @require Number.js
// @define Firebird.Array

	/**
	 * 提供一个处理数组的静态方法集合，另加了一些旧式浏览器未实现的方法。
	 * @class Firebird.Array
	 * @singleton
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 *
	 * A set of useful static methods to deal with arrays; provide missing methods for older browsers.
	 */
	(function () {
		// 开始特性检测
		var arrayPrototype = Array.prototype,
			slice = arrayPrototype.slice,
			supportsSplice = (function () {
				var array = [],
					lengthBefore,
					j = 20;

				if (!array.splice) {
					return false;
				}

				// This detects a bug in IE8 splice method:
				// see http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/6e946d03-e09f-4b22-a4dd-cd5e276bf05a/

				while (j--) {
					array.push("A");
				}

				array.splice(15, 0, "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F", "F");

				lengthBefore = array.length; //41
				array.splice(13, 0, "XXX"); // add one element

				if (lengthBefore + 1 != array.length) {
					return false;
				}
				// end IE8 bug

				return true;
			}()),
			supportsForEach = 'forEach' in arrayPrototype,
			supportsMap = 'map' in arrayPrototype,
			supportsIndexOf = 'indexOf' in arrayPrototype,
			supportsEvery = 'every' in arrayPrototype,
			supportsSome = 'some' in arrayPrototype,
			supportsFilter = 'filter' in arrayPrototype,
			supportsSort = (function () {
				var a = [1, 2, 3, 4, 5].sort(function () {
					return 0;
				});
				return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
			}()),
			supportsSliceOnNodeList = true,
			FirebirdArray,
			erase,
			replace,
			splice;

		try {
			// IE 6 - 8 will throw an error when using Array.prototype.slice on NodeList
			if (typeof document !== 'undefined') {
				slice.call(document.getElementsByTagName('body'));
			}
		} catch (e) {
			supportsSliceOnNodeList = false;
		}

		function fixArrayIndex(array, index) {
			return (index < 0) ? Math.max(0, array.length + index)
				: Math.min(array.length, index);
		}

		/**
		 * 将一个数组去掉其中的某些元素，并用新的元素填充
		 * 如
		 * var array = [1,2,3,4,5];
		 * replaceSim(array, 1, 2, [a,b]);
		 * // [1,a,b,4,5]
		 *
		 Does the same work as splice, but with a slightly more convenient signature. The splice
		 method has bugs in IE8, so this is the implementation we use on that platform.

		 The rippling of items in the array can be tricky. Consider two use cases:

		 index=2
		 removeCount=2
		 /=====\
		 +---+---+---+---+---+---+---+---+
		 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
		 +---+---+---+---+---+---+---+---+
		 /  \/  \/  \/  \
		 /   /\  /\  /\   \
		 /   /  \/  \/  \   +--------------------------+
		 /   /   /\  /\   +--------------------------+   \
		 /   /   /  \/  +--------------------------+   \   \
		 /   /   /   /+--------------------------+   \   \   \
		 /   /   /   /                             \   \   \   \
		 v   v   v   v                               v   v   v   v
		 +---+---+---+---+---+---+       +---+---+---+---+---+---+---+---+---+
		 | 0 | 1 | 4 | 5 | 6 | 7 |       | 0 | 1 | a | b | c | 4 | 5 | 6 | 7 |
		 +---+---+---+---+---+---+       +---+---+---+---+---+---+---+---+---+
		 A                               B        \=========/
		 insert=[a,b,c]

		 In case A, it is obvious that copying of [4,5,6,7] must be left-to-right so
		 that we don't end up with [0,1,6,7,6,7]. In case B, we have the opposite; we
		 must go right-to-left or else we would end up with [0,1,a,b,c,4,4,4,4].
		 */
		function replaceSim(array, index, removeCount, insert) {
			var add = insert ? insert.length : 0,
				length = array.length,
				pos = fixArrayIndex(array, index),
				remove,
				tailOldPos,
				tailNewPos,
				tailCount,
				lengthAfterRemove,
				i;

			// we try to use Array.push when we can for efficiency...
			if (pos === length) {
				if (add) {
					array.push.apply(array, insert);
				}
			} else {
				remove = Math.min(removeCount, length - pos);
				tailOldPos = pos + remove;
				tailNewPos = tailOldPos + add - remove;
				tailCount = length - tailOldPos;
				lengthAfterRemove = length - remove;

				if (tailNewPos < tailOldPos) { // case A
					for (i = 0; i < tailCount; ++i) {
						array[tailNewPos + i] = array[tailOldPos + i];
					}
				} else if (tailNewPos > tailOldPos) { // case B
					for (i = tailCount; i--;) {
						array[tailNewPos + i] = array[tailOldPos + i];
					}
				} // else, add == remove (nothing to do)

				if (add && pos === lengthAfterRemove) {
					array.length = lengthAfterRemove; // truncate array
					array.push.apply(array, insert);
				} else {
					array.length = lengthAfterRemove + add; // reserves space
					for (i = 0; i < add; ++i) {
						array[pos + i] = insert[i];
					}
				}
			}

			return array;
		}

		function replaceNative(array, index, removeCount, insert) {
			if (insert && insert.length) {
				// Inserting at index zero with no removing: use unshift
				if (index === 0 && !removeCount) {
					array.unshift.apply(array, insert);
				}
				// Inserting/replacing in middle of array
				else if (index < array.length) {
					array.splice.apply(array, [index, removeCount].concat(insert));
				}
				// Appending to array
				else {
					array.push.apply(array, insert);
				}
			} else {
				array.splice(index, removeCount);
			}
			return array;
		}

		function eraseSim(array, index, removeCount) {
			return replaceSim(array, index, removeCount);
		}

		function eraseNative(array, index, removeCount) {
			array.splice(index, removeCount);
			return array;
		}

		function spliceSim(array, index, removeCount) {
			var pos = fixArrayIndex(array, index),
				removed = array.slice(index, fixArrayIndex(array, pos + removeCount));

			if (arguments.length < 4) {
				replaceSim(array, pos, removeCount);
			} else {
				replaceSim(array, pos, removeCount, slice.call(arguments, 3));
			}

			return removed;
		}

		function spliceNative(array) {
			return array.splice.apply(array, slice.call(arguments, 1));
		}

		erase = supportsSplice ? eraseNative : eraseSim;
		replace = supportsSplice ? replaceNative : replaceSim;
		splice = supportsSplice ? spliceNative : spliceSim;

		// NOTE: from here on, use erase, replace or splice (not native methods)...

		FirebirdArray = Firebird.Array = {
			/**
			 * 迭代一个数组或可迭代的值，每次迭代都会激起回调
			 * Iterates an array or an iterable value and invoke the given callback function for each item.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *     var peoples = ['小戴', '小郭', '朱德', '糊糊'];
			 *
			 *     Firebird.Array.each(peoples, function(name, index, peoplesItSelf) {
             *         console.log(name);
             *     });
			 *
			 *     var sum = function() {
             *         var sum = 0;
             *
             *         Firebird.Array.each(arguments, function(value) {
             *             sum += value;
             *         });
             *
             *         return sum;
             *     };
			 *
			 *     sum(1, 2, 3); // returns 6
			 *
			 * 若是在回调中返回了false，迭代将会停止
			 * The iteration can be stopped by returning false in the function callback.
			 *
			 *     Firebird.Array.each(peoples, function(name, index, peoplesItSelf) {
             *         if (name === '小郭') {
             *             return false; // 这里后不再继续
             *         }
             *     });
			 *        </code>
			 * </pre>
			 * {@link Firebird#each Firebird.each} is alias for {@link Firebird.Array#each Firebird.Array.each}
			 *
			 * @param {Array/NodeList/Object} iterable The value to be iterated. If this
			 * argument is not iterable, the callback function is called once.
			 * @param {Function} fn The callback function. If it returns false, the iteration stops and this method returns
			 * the current `index`.
			 * @param {Object} fn.item The item at the current `index` in the passed `array`
			 * @param {Number} fn.index The current `index` within the `array`
			 * @param {Array} fn.allItems The `array` itself which was passed as the first argument
			 * @param {Boolean} fn.return Return false to stop iteration.
			 * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
			 * @param {Boolean} reverse (Optional) Reverse the iteration order (loop from the end to the beginning)
			 * Defaults false
			 * @return {Boolean} See description for the `fn` parameter.
			 */
			each: function (array, fn, scope, reverse) {
				array = FirebirdArray.from(array);

				var i,
					ln = array.length;

				if (reverse !== true) {
					for (i = 0; i < ln; i++) {
						if (fn.call(scope || array[i], array[i], i, array) === false) {
							return i;
						}
					}
				}
				else {
					for (i = ln - 1; i > -1; i--) {
						if (fn.call(scope || array[i], array[i], i, array) === false) {
							return i;
						}
					}
				}

				return true;
			},
			/**
			 * 迭代一个数组，在迭代每个元素时会调用给定的回调方法。请注意，如果浏览器支持原生 Array.prototype.forEach 方法的话，
			 * 本方法只是做简单的代理。同时本方法不支持在迭代时，在回调中返回false来停止迭代。
			 * Iterates an array and invoke the given callback function for each item. Note that this will simply
			 * delegate to the native Array.prototype.forEach method if supported. It doesn't support stopping the
			 * iteration by returning false in the callback function like {@link Firebird.Array#each}. However, performance
			 * could be much better in modern browsers comparing with {@link Firebird.Array#each}
			 *
			 * @param {Array} array The array to iterate
			 * @param {Function} fn The callback function.
			 * @param {Object} fn.item The item at the current `index` in the passed `array`
			 * @param {Number} fn.index The current `index` within the `array`
			 * @param {Array}  fn.allItems The `array` itself which was passed as the first argument
			 * @param {Object} scope (Optional) The execution scope (`this`) in which the specified function is executed.
			 */
			forEach: supportsForEach ? function (array, fn, scope) {
				array.forEach(fn, scope);
			} : function (array, fn, scope) {
				var i = 0,
					ln = array.length;

				for (; i < ln; i++) {
					fn.call(scope, array[i], i, array);
				}
			},
			/**
			 * 获取元素在数组中的索引，如果没有找到，则返回-1，在缺失原生 Array.prototype.indexOf 方法的IE浏览器可以作为补充。
			 * Get the index of the provided `item` in the given `array`, a supplement for the
			 * missing arrayPrototype.indexOf in Internet Explorer.
			 *
			 * @param {Array} array The array to check
			 * @param {Object} item The item to look for
			 * @param {Number} from (Optional) The index at which to begin the search
			 * @return {Number} The index of item in the array (or -1 if it is not found)
			 */
			indexOf: supportsIndexOf ? function (array, item, from) {
				return arrayPrototype.indexOf.call(array, item, from);
			} : function (array, item, from) {
				var i, length = array.length;

				for (i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++) {
					if (array[i] === item) {
						return i;
					}
				}

				return -1;
			},
			/**
			 * 检查元素是否在数组中
			 * Checks whether or not the given `array` contains the specified `item`
			 *
			 * 例子
			 * Firebird.Array.contains([1,2], 1)
			 * // true
			 * Firebird.Array.contains([1,2], 3)
			 * // false
			 *
			 * @param {Array} array The array to check
			 * @param {Object} item The item to look for
			 * @return {Boolean} True if the array contains the item, false otherwise
			 */
			contains: supportsIndexOf ? function (array, item) {
				return arrayPrototype.indexOf.call(array, item) !== -1;
			} : function (array, item) {
				var i, ln;

				for (i = 0, ln = array.length; i < ln; i++) {
					if (array[i] === item) {
						return true;
					}
				}

				return false;
			},
			/**
			 * 把可迭代的内容转成数组
			 * Converts any iterable (numeric indices and a length property) into a true array.
			 *
			 *     function test() {
             *         var args = Firebird.Array.toArray(arguments),
             *             fromSecondToLastArgs = Firebird.Array.toArray(arguments, 1);
             *
             *         alert(args.join(' '));
             *         alert(fromSecondToLastArgs.join(' '));
             *     }
			 *
			 *     test('just', 'testing', 'here'); // alerts 'just testing here';
			 *                                      // alerts 'testing here';
			 *
			 *     Firebird.Array.toArray(document.getElementsByTagName('div')); // will convert the NodeList into an array
			 *     Firebird.Array.toArray('splitted'); // returns ['s', 'p', 'l', 'i', 't', 't', 'e', 'd']
			 *     Firebird.Array.toArray('splitted', 0, 3); // returns ['s', 'p', 'l']
			 *
			 * {@link Firebird#toArray Firebird.toArray} is alias for {@link Firebird.Array#toArray Firebird.Array.toArray}
			 *
			 * @param {Object} iterable the iterable object to be turned into a true Array.
			 * @param {Number} start (Optional) a zero-based index that specifies the start of extraction. Defaults to 0
			 * @param {Number} end (Optional) a 1-based index that specifies the end of extraction. Defaults to the last
			 * index of the iterable value
			 * @return {Array} array
			 */
			toArray: function (iterable, start, end) {
				if (!iterable || !iterable.length) {
					return [];
				}

				if (typeof iterable === 'string') {
					iterable = iterable.split('');
				}

				if (supportsSliceOnNodeList) {
					return slice.call(iterable, start || 0, end || iterable.length);
				}

				var array = [],
					i;

				start = start || 0;
				end = end ? ((end < 0) ? iterable.length + end : end) : iterable.length;

				for (i = start; i < end; i++) {
					array.push(iterable[i]);
				}

				return array;
			},
			/**
			 * 从一个数组中摘取属性
			 * Plucks the value of a property from each item in the Array. Example:
			 *
			 *     Firebird.Array.pluck(Firebird.query("p"), "className"); // [el1.className, el2.className, ..., elN.className]
			 *
			 * @param {Array/NodeList} array The Array of items to pluck the value from.
			 * @param {String} propertyName The property name to pluck from each element.
			 * @return {Array} The value from each item in the Array.
			 */
			pluck: function (array, propertyName) {
				var ret = [],
					i, ln, item;

				for (i = 0, ln = array.length; i < ln; i++) {
					item = array[i];

					ret.push(item[propertyName]);
				}

				return ret;
			},
			/**
			 * Creates a new array with the results of calling a provided function on every element in this array.
			 *
			 * @param {Array} array
			 * @param {Function} fn Callback function for each item
			 * @param {Mixed} fn.item Current item.
			 * @param {Number} fn.index Index of the item.
			 * @param {Array} fn.array The whole array that's being iterated.
			 * @param {Object} [scope] Callback function scope
			 * @return {Array} results
			 */
			map: supportsMap ? function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.map 的第二个参数必须是函数.');
				}
				return array.map(fn, scope);
			} : function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.map 的第二个参数必须是函数.');
				}
				var results = [],
					i = 0,
					len = array.length;

				for (; i < len; i++) {
					results[i] = fn.call(scope, array[i], i, array);
				}

				return results;
			},
			/**
			 * Executes the specified function for each array element until the function returns a falsy value.
			 * If such an item is found, the function will return false immediately.
			 * Otherwise, it will return true.
			 *
			 * @param {Array} array
			 * @param {Function} fn Callback function for each item
			 * @param {Mixed} fn.item Current item.
			 * @param {Number} fn.index Index of the item.
			 * @param {Array} fn.array The whole array that's being iterated.
			 * @param {Object} scope Callback function scope
			 * @return {Boolean} True if no false value is returned by the callback function.
			 */
			every: supportsEvery ? function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.every 的第二个参数必须是函数.');
				}
				return array.every(fn, scope);
			} : function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.every 的第二个参数必须是函数.');
				}
				var i = 0,
					ln = array.length;

				for (; i < ln; ++i) {
					if (!fn.call(scope, array[i], i, array)) {
						return false;
					}
				}

				return true;
			},
			/**
			 * Executes the specified function for each array element until the function returns a truthy value.
			 * If such an item is found, the function will return true immediately. Otherwise, it will return false.
			 *
			 * @param {Array} array
			 * @param {Function} fn Callback function for each item
			 * @param {Mixed} fn.item Current item.
			 * @param {Number} fn.index Index of the item.
			 * @param {Array} fn.array The whole array that's being iterated.
			 * @param {Object} scope Callback function scope
			 * @return {Boolean} True if the callback function returns a truthy value.
			 */
			some: supportsSome ? function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.some 的第二个参数必须是函数.');
				}
				return array.some(fn, scope);
			} : function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.some 的第二个参数必须是函数.');
				}
				var i = 0,
					ln = array.length;

				for (; i < ln; ++i) {
					if (fn.call(scope, array[i], i, array)) {
						return true;
					}
				}

				return false;
			},
			/**
			 * 浅层比较两个数组是否一致
			 * Shallow compares the contents of 2 arrays using strict equality.
			 * @param {Array} array1
			 * @param {Array} array2
			 * @return {Boolean} `true` if the arrays are equal.
			 */
			equals: function (array1, array2) {
				var len1 = array1.length,
					len2 = array2.length,
					i;

				// Short circuit if the same array is passed twice
				if (array1 === array2) {
					return true;
				}

				if (len1 !== len2) {
					return false;
				}

				for (i = 0; i < len1; ++i) {
					if (array1[i] !== array2[i]) {
						return false;
					}
				}

				return true;
			},
			/**
			 * 过滤一个数组中未定义的值
			 * Filter through an array and remove empty item as defined in {@link Firebird#isEmpty Firebird.isEmpty}
			 * 例子
			 * Firebird.Array.clean([1,2,null,2])
			 * // [1, 2, 2]
			 *
			 * See {@link Firebird.Array#filter}
			 *
			 * @param {Array} array
			 * @return {Array} results
			 */
			clean: function (array) {
				var results = [],
					i = 0,
					ln = array.length,
					item;

				for (; i < ln; i++) {
					item = array[i];

					if (!Firebird.isEmpty(item)) {
						results.push(item);
					}
				}

				return results;
			},
			/**
			 * 数组去重，返回的是一个新的数组
			 * Returns a new array with unique items
			 *
			 * @param {Array} array
			 * @return {Array} results
			 */
			unique: function (array) {
				var clone = [],
					i = 0,
					ln = array.length,
					item;

				for (; i < ln; i++) {
					item = array[i];

					if (FirebirdArray.indexOf(clone, item) === -1) {
						clone.push(item);
					}
				}

				return clone;
			},
			/**
			 * 数组过滤器
			 * Creates a new array with all of the elements of this array for which
			 * the provided filtering function returns true.
			 *
			 * @param {Array} array
			 * @param {Function} fn Callback function for each item
			 * @param {Mixed} fn.item Current item.
			 * @param {Number} fn.index Index of the item.
			 * @param {Array} fn.array The whole array that's being iterated.
			 * @param {Object} scope Callback function scope
			 * @return {Array} results
			 */
			filter: supportsFilter ? function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.filter 的第二个参数必须是函数.');
				}
				return array.filter(fn, scope);
			} : function (array, fn, scope) {
				if (!fn) {
					firebird.error('Firebird.Array.filter 的第二个参数必须是函数.');
				}
				var results = [],
					i = 0,
					ln = array.length;

				for (; i < ln; i++) {
					if (fn.call(scope, array[i], i, array)) {
						results.push(array[i]);
					}
				}

				return results;
			},
			/**
			 * 查找数组中符合回调的第一个元素
			 * Returns the first item in the array which elicits a true return value from the
			 * passed selection function.
			 * @param {Array} array The array to search
			 * @param {Function} fn The selection function to execute for each item.
			 * @param {Mixed} fn.item The array item.
			 * @param {String} fn.index The index of the array item.
			 * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the
			 * function is executed. Defaults to the array
			 * @return {Object} The first item in the array which returned true from the selection
			 * function, or null if none was found.
			 */
			findBy: function (array, fn, scope) {
				var i = 0,
					len = array.length;

				for (; i < len; i++) {
					if (fn.call(scope || array, array[i], i)) {
						return array[i];
					}
				}
				return null;
			},
			/**
			 * 把一个值转换成数组
			 * 返回：
			 * - 如果给的值是 `undefined` 或 `null`，那么返回一个空数组
			 * - 如果给的是一个数组，那么返回本身
			 * - 如果给的一个类数组（可以被迭代的）{@link Firebird#isIterable iterable}（arguments, NodeList and alike），
			 *     则返回一个数组拷贝
			 * - 否则，返回一个只含有一个元素（给定值）的数组
			 *
			 * Converts a value to an array if it's not already an array;
			 *
			 * returns:
			 *
			 * - An empty array if given value is `undefined` or `null`
			 * - Itself if given value is already an array
			 * - An array copy if given value is {@link Firebird#isIterable iterable} (arguments, NodeList and alike)
			 * - An array with one item which is the given value, otherwise
			 *
			 * @param {Object} value The value to convert to an array if it's not already is an array
			 * @param {Boolean} newReference (Optional) True to clone the given array and return a new reference if necessary,
			 * defaults to false
			 * @return {Array} array
			 */
			from: function (value, newReference) {
				if (value === undefined || value === null) {
					return [];
				}

				if (Firebird.isArray(value)) {
					return (newReference) ? slice.call(value) : value;
				}

				var type = typeof value;
				// Both strings and functions will have a length property. In phantomJS, NodeList
				// instances report typeof=='function' but don't have an apply method...
				if (value && value.length !== undefined && type !== 'string' && (type !== 'function' || !value.apply)) {
					return FirebirdArray.toArray(value);
				}

				return [value];
			},
			/**
			 * 去除数组中的某个元素
			 * Removes the specified item from the array if it exists
			 *
			 * @param {Array} array The array
			 * @param {Object} item The item to remove
			 * @return {Array} The passed array itself
			 */
			remove: function (array, item) {
				var index = FirebirdArray.indexOf(array, item);

				if (index !== -1) {
					erase(array, index, 1);
				}

				return array;
			},
			/**
			 * 把一个元素加入到数组中
			 * Push an item into the array only if the array doesn't contain it yet
			 *
			 * @param {Array} array The array
			 * @param {Object} item The item to include
			 */
			include: function (array, item) {
				if (!FirebirdArray.contains(array, item)) {
					array.push(item);
				}
			},
			/**
			 * 克隆一个没有引用的数组，请注意这个方法不会递归调用，所以与 Firebird.clone 是不一样的。
			 * 这只是一个简单的转换，比 Array.prototype.slice.call(array) 好记一点
			 * Clone a flat array without referencing the previous one. Note that this is different
			 * from Firebird.clone since it doesn't handle recursive cloning. It's simply a convenient, easy-to-remember method
			 * for Array.prototype.slice.call(array)
			 *
			 * @param {Array} array The array
			 * @return {Array} The clone array
			 */
			clone: function (array) {
				return slice.call(array);
			},
			/**
			 * 合并多个数组至一个没有重复的数组
			 * Merge multiple arrays into one with unique items.
			 *
			 * {@link Firebird.Array#union} is alias for {@link Firebird.Array#merge}
			 *
			 * @param {Array} array1
			 * @param {Array} array2
			 * @param {Array} etc
			 * @return {Array} merged
			 */
			merge: function () {
				var args = slice.call(arguments),
					array = [],
					i, ln;

				for (i = 0, ln = args.length; i < ln; i++) {
					array = array.concat(args[i]);
				}

				return FirebirdArray.unique(array);
			},
			/**
			 * 返回每个数组中都有的元素
			 * Merge multiple arrays into one with unique items that exist in all of the arrays.
			 * 例子
			 * Firebird.Array.intersect([1,2,3], [1,2,3,4], [1,2])
			 * // [1, 2]
			 *
			 * @param {Array} array1
			 * @param {Array} array2
			 * @param {Array} etc
			 * @return {Array} intersect
			 */
			intersect: function () {
				var intersection = [],
					arrays = slice.call(arguments),
					arraysLength,
					array,
					arrayLength,
					minArray,
					minArrayIndex,
					minArrayCandidate,
					minArrayLength,
					element,
					elementCandidate,
					elementCount,
					i, j, k;

				if (!arrays.length) {
					return intersection;
				}

				// Find the smallest array
				arraysLength = arrays.length;
				for (i = minArrayIndex = 0; i < arraysLength; i++) {
					minArrayCandidate = arrays[i];
					if (!minArray || minArrayCandidate.length < minArray.length) {
						minArray = minArrayCandidate;
						minArrayIndex = i;
					}
				}

				minArray = FirebirdArray.unique(minArray);
				erase(arrays, minArrayIndex, 1);

				// Use the smallest unique'd array as the anchor loop. If the other array(s) do contain
				// an item in the small array, we're likely to find it before reaching the end
				// of the inner loop and can terminate the search early.
				minArrayLength = minArray.length;
				arraysLength = arrays.length;
				for (i = 0; i < minArrayLength; i++) {
					element = minArray[i];
					elementCount = 0;

					for (j = 0; j < arraysLength; j++) {
						array = arrays[j];
						arrayLength = array.length;
						for (k = 0; k < arrayLength; k++) {
							elementCandidate = array[k];
							if (element === elementCandidate) {
								elementCount++;
								break;
							}
						}
					}

					if (elementCount === arraysLength) {
						intersection.push(element);
					}
				}

				return intersection;
			},
			/**
			 * 返回两个数组不一样的元素
			 * Perform a set difference A-B by subtracting all items in array B from array A.
			 * 例子
			 * Firebird.Array.difference([1,2,3], [1,2])
			 * // [3]
			 *
			 * @param {Array} arrayA
			 * @param {Array} arrayB
			 * @return {Array} difference
			 */
			difference: function (arrayA, arrayB) {
				var clone = slice.call(arrayA),
					ln = clone.length,
					i, j, lnB;

				for (i = 0, lnB = arrayB.length; i < lnB; i++) {
					for (j = 0; j < ln; j++) {
						if (clone[j] === arrayB[i]) {
							erase(clone, j, 1);
							j--;
							ln--;
						}
					}
				}

				return clone;
			},
			/**
			 * 返回一个数组的拷贝，这个方法与本地调用 "Array.prototype.slice.call(array, begin, end)" 是等效的。
			 *
			 * Returns a shallow copy of a part of an array. This is equivalent to the native
			 * call "Array.prototype.slice.call(array, begin, end)". This is often used when "array"
			 * is "arguments" since the arguments object does not supply a slice method but can
			 * be the context object to Array.prototype.slice.
			 *
			 * @param {Array} array The array (or arguments object).
			 * @param {Number} begin The index at which to begin. Negative values are offsets from
			 * the end of the array.
			 * @param {Number} end The index at which to end. The copied items do not include
			 * end. Negative values are offsets from the end of the array. If end is omitted,
			 * all items up to the end of the array are copied.
			 * @return {Array} The copied piece of the array.
			 * @method slice
			 */
			// Note: IE6 will return [] on slice.call(x, undefined).
			slice: ([1, 2].slice(1, undefined).length ?
					function (array, begin, end) {
						return slice.call(array, begin, end);
					} :
					// at least IE6 uses arguments.length for variadic signature
					function (array, begin, end) {
						// After tested for IE 6, the one below is of the best performance
						// see http://jsperf.com/slice-fix
						if (typeof begin === 'undefined') {
							return slice.call(array);
						}
						if (typeof end === 'undefined') {
							return slice.call(array, begin);
						}
						return slice.call(array, begin, end);
					}
			),
			/**
			 * 对数组排序
			 * Sorts the elements of an Array.
			 * By default, this method sorts the elements alphabetically and ascending.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.Array.sort([1,5,2,6,7,8,66])
			 * // [1, 2, 5, 6, 66, 7, 8] 注意此处的 66
			 * Firebird.Array.sort([1,5,2,6,7,8,66], function(a,b){return a>b})
			 * // [1, 2, 5, 6, 7, 8, 66]
			 * Firebird.Array.sort([1,5,2,6,7,8,66], function(a,b){return a<b})
			 * // [66, 8, 7, 6, 5, 2, 1]
			 *        </code>
			 * </pre>
			 * @param {Array} array The array to sort.
			 * @param {Function} sortFn (optional) The comparison function.
			 * @param {Mixed} sortFn.a An item to compare.
			 * @param {Mixed} sortFn.b Another item to compare.
			 * @return {Array} The sorted array.
			 */
			sort: supportsSort ? function (array, sortFn) {
				if (sortFn) {
					return array.sort(sortFn);
				} else {
					return array.sort();
				}
			} : function (array, sortFn) {
				var length = array.length,
					i = 0,
					comparison,
					j, min, tmp;

				for (; i < length; i++) {
					min = i;
					for (j = i + 1; j < length; j++) {
						if (sortFn) {
							comparison = sortFn(array[j], array[min]);
							if (comparison < 0) {
								min = j;
							}
						} else if (array[j] < array[min]) {
							min = j;
						}
					}
					if (min !== i) {
						tmp = array[i];
						array[i] = array[min];
						array[min] = tmp;
					}
				}

				return array;
			},
			/**
			 * 扁平化数组
			 * Recursively flattens into 1-d Array. Injects Arrays inline.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 *        Firebird.Array.flatten([[1,2],[3,4]])
			 *        // [1, 2, 3, 4]
			 *        </code>
			 * </pre>
			 * @param {Array} array The array to flatten
			 * @return {Array} The 1-d array.
			 */
			flatten: function (array) {
				var worker = [];

				function rFlatten(a) {
					var i, ln, v;

					for (i = 0, ln = a.length; i < ln; i++) {
						v = a[i];

						if (Firebird.isArray(v)) {
							rFlatten(v);
						} else {
							worker.push(v);
						}
					}

					return worker;
				}

				return rFlatten(array);
			},
			/**
			 * 返回数组中的最小值
			 * Returns the minimum value in the Array.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.Array.min([{a:3},{a:2},{a:7}], function(min, item){return min.a > item.a })
			 * // Object {a: 3}
			 * Firebird.Array.min([{a:3},{a:2},{a:7}], function(min, item){return min.a < item.a })
			 * // Object {a: 3}
			 * Firebird.Array.min([{a:3},{a:2},{a:7}], function(min, item){return min.a < item.a ? 1 :　-1})
			 * // Object {a: 7}
			 * Firebird.Array.min([{a:3},{a:2},{a:7}], function(min, item){return min.a < item.a ? -1 :　1})
			 * // Object {a: 2}
			 *        </code>
			 * </pre>
			 * @param {Array/NodeList} array The Array from which to select the minimum value.
			 * @param {Function} comparisonFn (optional) a function to perform the comparision which determines minimization.
			 * If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1
			 * @param {Mixed} comparisonFn.min Current minimum value.
			 * @param {Mixed} comparisonFn.item The value to compare with the current minimum.
			 * @return {Object} minValue The minimum value
			 */
			min: function (array, comparisonFn) {
				var min = array[0],
					i, ln, item;

				for (i = 0, ln = array.length; i < ln; i++) {
					item = array[i];

					if (comparisonFn) {
						if (comparisonFn(min, item) === 1) {
							min = item;
						}
					}
					else {
						if (item < min) {
							min = item;
						}
					}
				}

				return min;
			},
			/**
			 * 查找最大值
			 * Returns the maximum value in the Array.
			 *
			 * @param {Array/NodeList} array The Array from which to select the maximum value.
			 * @param {Function} comparisonFn (optional) a function to perform the comparision which determines maximization.
			 * If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1
			 * @param {Mixed} comparisonFn.max Current maximum value.
			 * @param {Mixed} comparisonFn.item The value to compare with the current maximum.
			 * @return {Object} maxValue The maximum value
			 */
			max: function (array, comparisonFn) {
				var max = array[0],
					i, ln, item;

				for (i = 0, ln = array.length; i < ln; i++) {
					item = array[i];

					if (comparisonFn) {
						if (comparisonFn(max, item) === -1) {
							max = item;
						}
					}
					else {
						if (item > max) {
							max = item;
						}
					}
				}

				return max;
			},
			/**
			 * 计算平均值
			 * Calculates the mean of all items in the array.
			 * Firebird.Array.mean([99, 1])
			 * // 50
			 * @param {Array} array The Array to calculate the mean value of.
			 * @return {Number} The mean.
			 */
			mean: function (array) {
				return array.length > 0 ? FirebirdArray.sum(array) / array.length : undefined;
			},
			/**
			 * 计算平均值, Firebird.Array.mean 的别名
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * Firebird.Array.mean([99, 1])
			 * // 50
			 *        </code>
			 * </pre>
			 * @param {Array} array 需要计算的数组.
			 * @return {Number} 平均值.
			 */
			avg: function (array) {
				return Firebird.Array.mean(array);
			},
			/**
			 * 计算合计值
			 * Calculates the sum of all items in the given array.
			 *
			 * @param {Array} array The Array to calculate the sum value of.
			 * @return {Number} The sum.
			 */
			sum: function (array) {
				var sum = 0,
					i, ln, item;

				for (i = 0, ln = array.length; i < ln; i++) {
					item = array[i];

					sum += item;
				}

				return sum;
			},
			/**
			 * 通过给定的元素创建一个键映射（对象），其键是数组元素的值。该映射中的值是给定的数组中元素的索引+1。
			 * Creates a map (object) keyed by the elements of the given array. The values in
			 * the map are the index+1 of the array element.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * 例子:
			 *
			 *      var map = Firebird.Array.toMap(['a','b','c']);
			 *
			 *      // map = { a: 1, b: 2, c: 3 };
			 *
			 * Or a key property can be specified:
			 *
			 *      var map = Firebird.Array.toMap([
			 *              { name: 'a' },
			 *              { name: 'b' },
			 *              { name: 'c' }
			 *          ], 'name');
			 *
			 *      // map = { a: 1, b: 2, c: 3 };
			 *
			 * Lastly, a key extractor can be provided:
			 *
			 *      var map = Firebird.Array.toMap([
			 *              { name: 'a' },
			 *              { name: 'b' },
			 *              { name: 'c' }
			 *          ], function (obj) { return obj.name.toUpperCase(); });
			 *
			 *      // map = { A: 1, B: 2, C: 3 };
			 *        </code>
			 * </pre>
			 * @param {Array} array The Array to create the map from.
			 * @param {String/Function} [getKey] Name of the object property to use
			 * as a key or a function to extract the key.
			 * @param {Object} [scope] Value of this inside callback.
			 * @return {Object} The resulting map.
			 */
			toMap: function (array, getKey, scope) {
				var map = {},
					i = array.length;

				if (!getKey) {
					while (i--) {
						map[array[i]] = i + 1;
					}
				} else if (typeof getKey == 'string') {
					while (i--) {
						map[array[i][getKey]] = i + 1;
					}
				} else {
					while (i--) {
						map[getKey.call(scope, array[i])] = i + 1;
					}
				}

				return map;
			},
			/**
			 * 通过给定的数组创建一个值映射（对象）
			 * Creates a map (object) keyed by a property of elements of the given array. The values in
			 * the map are the array element.
			 * @example
			 * 例子
			 * <pre>
			 *     <code>
			 * 例子:
			 *
			 *      var map = Firebird.Array.toMap(['a','b','c']);
			 *
			 *      // map = { a: 'a', b: 'b', c: 'c' };
			 *
			 * Or a key property can be specified:
			 *
			 *      var map = Firebird.Array.toMap([
			 *              { name: 'a' },
			 *              { name: 'b' },
			 *              { name: 'c' }
			 *          ], 'name');
			 *
			 *      // map = { a: {name: 'a'}, b: {name: 'b'}, c: {name: 'c'} };
			 *
			 * Lastly, a key extractor can be provided:
			 *
			 *      var map = Firebird.Array.toMap([
			 *              { name: 'a' },
			 *              { name: 'b' },
			 *              { name: 'c' }
			 *          ], function (obj) { return obj.name.toUpperCase(); });
			 *
			 *      // map = { A: {name: 'a'}, B: {name: 'b'}, C: {name: 'c'} };
			 *        </code>
			 * </pre>
			 * @param {Array} array The Array to create the map from.
			 * @param {String/Function} [getKey] Name of the object property to use
			 * as a key or a function to extract the key.
			 * @param {Object} [scope] Value of this inside callback.
			 * @return {Object} The resulting map.
			 */
			toValueMap: function (array, getKey, scope) {
				var map = {},
					i = array.length;

				if (!getKey) {
					while (i--) {
						map[array[i]] = array[i];
					}
				} else if (typeof getKey == 'string') {
					while (i--) {
						map[array[i][getKey]] = array[i];
					}
				} else {
					while (i--) {
						map[getKey.call(scope, array[i])] = array[i];
					}
				}

				return map;
			},
			_replaceSim: replaceSim, // for unit testing
			_spliceSim: spliceSim,
			/**
			 * 移除数组中的元素
			 * Removes items from an array. This is functionally equivalent to the splice method
			 * of Array, but works around bugs in IE8's splice method and does not copy the
			 * removed elements in order to return them (because very often they are ignored).
			 *
			 * @param {Array} array The Array on which to replace.
			 * @param {Number} index The index in the array at which to operate.
			 * @param {Number} removeCount The number of items to remove at index.
			 * @return {Array} The array passed.
			 * @method
			 */
			erase: erase,
			/**
			 * 往数组插入一个元素
			 * Inserts items in to an array.
			 *
			 * @param {Array} array The Array in which to insert.
			 * @param {Number} index The index in the array at which to operate.
			 * @param {Array} items The array of items to insert at index.
			 * @return {Array} The array passed.
			 */
			insert: function (array, index, items) {
				return replace(array, index, 0, items);
			},
			/**
			 * 替换数组中的元素
			 * Replaces items in an array. This is functionally equivalent to the splice method
			 * of Array, but works around bugs in IE8's splice method and is often more convenient
			 * to call because it accepts an array of items to insert rather than use a variadic
			 * argument list.
			 *
			 * @param {Array} array The Array on which to replace.
			 * @param {Number} index The index in the array at which to operate.
			 * @param {Number} removeCount The number of items to remove at index (can be 0).
			 * @param {Array} insert (optional) An array of items to insert at index.
			 * @return {Array} The array passed.
			 * @method
			 */
			replace: replace,
			/**
			 * Replaces items in an array. This is equivalent to the splice method of Array, but
			 * works around bugs in IE8's splice method. The signature is exactly the same as the
			 * splice method except that the array is the first argument. All arguments following
			 * removeCount are inserted in the array at index.
			 *
			 * @param {Array} array The Array on which to replace.
			 * @param {Number} index The index in the array at which to operate.
			 * @param {Number} removeCount The number of items to remove at index (can be 0).
			 * @param {Object...} elements The elements to add to the array. If you don't specify
			 * any elements, splice simply removes elements from the array.
			 * @return {Array} An array containing the removed items.
			 * @method
			 */
			splice: splice,
			/**
			 * 将新元素压入一个数组
			 * Pushes new items onto the end of an Array.
			 *
			 * Passed parameters may be single items, or arrays of items. If an Array is found in the argument list, all its
			 * elements are pushed into the end of the target Array.
			 *
			 * @param {Array} target The Array onto which to push new items
			 * @param {Object...} elements The elements to add to the array. Each parameter may
			 * be an Array, in which case all the elements of that Array will be pushed into the end of the
			 * destination Array.
			 * @return {Array} An array containing all the new items push onto the end.
			 *
			 */
			push: function (array) {
				var len = arguments.length,
					i = 1,
					newItem;

				if (array === undefined) {
					array = [];
				} else if (!Firebird.isArray(array)) {
					array = [array];
				}
				for (; i < len; i++) {
					newItem = arguments[i];
					Array.prototype.push[Firebird.isIterable(newItem) ? 'apply' : 'call'](array, newItem);
				}
				return array;
			}
		};

		/**
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#each
		 */
		Firebird.each = FirebirdArray.each;

		/**
		 * @method
		 * @member Firebird.Array
		 * @inheritdoc Firebird.Array#merge
		 */
		FirebirdArray.union = FirebirdArray.merge;

		/**
		 * Old alias to {@link Firebird.Array#min}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#min} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#min
		 */
		Firebird.min = FirebirdArray.min;

		/**
		 * Old alias to {@link Firebird.Array#max}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#max} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#max
		 */
		Firebird.max = FirebirdArray.max;

		/**
		 * Old alias to {@link Firebird.Array#sum}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#sum} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#sum
		 */
		Firebird.sum = FirebirdArray.sum;

		/**
		 * Old alias to {@link Firebird.Array#mean}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#mean} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#mean
		 */
		Firebird.mean = FirebirdArray.mean;

		/**
		 * Old alias to {@link Firebird.Array#flatten}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#flatten} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#flatten
		 */
		Firebird.flatten = FirebirdArray.flatten;

		/**
		 * Old alias to {@link Firebird.Array#clean}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#clean} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#clean
		 */
		Firebird.clean = FirebirdArray.clean;

		/**
		 * Old alias to {@link Firebird.Array#unique}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#unique} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#unique
		 */
		Firebird.unique = FirebirdArray.unique;

		/**
		 * Old alias to {@link Firebird.Array#pluck Firebird.Array.pluck}
		 * @deprecated 4.0.0 Use {@link Firebird.Array#pluck Firebird.Array.pluck} instead
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#pluck
		 */
		Firebird.pluck = FirebirdArray.pluck;

		/**
		 * @method
		 * @member Firebird
		 * @inheritdoc Firebird.Array#toArray
		 */
		Firebird.toArray = function () {
			return FirebirdArray.toArray.apply(FirebirdArray, arguments);
		};
	}());

// @tag foundation,core
// @require Array.js
// @define Firebird.Function

	/**
	 * 一个处理函数的静态方法集合
	 * @class Firebird.Function
	 *
	 * A collection of useful static methods to deal with function callbacks
	 * @singleton
	 * @alternateClassName Firebird.util.Functions
	 */
	Firebird.Function = {
		/**
		 * 这个方法在整个框架中都有广泛的使用。
		 * A very commonly used method throughout the framework. It acts as a wrapper around another method
		 * which originally accepts 2 arguments for `name` and `value`.
		 * The wrapped function then allows "flexible" value setting of either:
		 *
		 * - `name` and `value` as 2 arguments
		 * - one single object argument with multiple key - value pairs
		 * @example
		 * <pre>
		 *     <code>
		 * 例子:
		 *
		 *     var setValue = Firebird.Function.flexSetter(function(name, value) {
         *         this[name] = value;
         *     });
		 *
		 *     // Afterwards
		 *     // Setting a single name - value
		 *     setValue('name1', 'value1');
		 *
		 *     // Settings multiple name - value pairs
		 *     setValue({
         *         name1: 'value1',
         *         name2: 'value2',
         *         name3: 'value3'
         *     });
		 *     </code>
		 * </pre>
		 * @param {Function} setter
		 * @returns {Function} flexSetter
		 */
		flexSetter: function (fn) {
			return function (a, b) {
				var k, i;

				if (a === null) {
					return this;
				}

				if (typeof a !== 'string') {
					for (k in a) {
						if (a.hasOwnProperty(k)) {
							fn.call(this, k, a[k]);
						}
					}

					if (Firebird.enumerables) {
						for (i = Firebird.enumerables.length; i--;) {
							k = Firebird.enumerables[i];
							if (a.hasOwnProperty(k)) {
								fn.call(this, k, a[k]);
							}
						}
					}
				} else {
					fn.call(this, a, b);
				}

				return this;
			};
		},
		/**
		 * Create a new function from the provided `fn`, change `this` to the provided scope, optionally
		 * overrides arguments for the call. (Defaults to the arguments passed by the caller)
		 *
		 * {@link Firebird#bind Firebird.bind} is alias for {@link Firebird.Function#bind Firebird.Function.bind}
		 *
		 * @param {Function} fn The function to delegate.
		 * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
		 * **If omitted, defaults to the default global environment object (usually the browser window).**
		 * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
		 * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
		 * if a number the args are inserted at the specified position
		 * @return {Function} The new function
		 */
		bind: function (fn, scope, args, appendArgs) {
			if (arguments.length === 2) {
				return function () {
					return fn.apply(scope, arguments);
				};
			}

			var method = fn,
				slice = Array.prototype.slice;

			return function () {
				var callArgs = args || arguments;

				if (appendArgs === true) {
					callArgs = slice.call(arguments, 0);
					callArgs = callArgs.concat(args);
				}
				else if (typeof appendArgs == 'number') {
					callArgs = slice.call(arguments, 0); // copy arguments first
					Firebird.Array.insert(callArgs, appendArgs, args);
				}

				return method.apply(scope || Firebird.global, callArgs);
			};
		},
		/**
		 * Create a new function from the provided `fn`, the arguments of which are pre-set to `args`.
		 * New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones.
		 * This is especially useful when creating callbacks.
		 * @example
		 * <pre>
		 *     <code>
		 * 例子:
		 *
		 *     var originalFunction = function(){
         *         alert(Firebird.Array.from(arguments).join(' '));
         *     };
		 *
		 *     var callback = Firebird.Function.pass(originalFunction, ['Hello', 'World']);
		 *
		 *     callback(); // alerts 'Hello World'
		 *     callback('by Me'); // alerts 'Hello World by Me'
		 *     </code>
		 * </pre>
		 * {@link Firebird#pass Firebird.pass} is alias for {@link Firebird.Function#pass Firebird.Function.pass}
		 *
		 * @param {Function} fn The original function
		 * @param {Array} args The arguments to pass to new callback
		 * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
		 * @return {Function} The new callback function
		 */
		pass: function (fn, args, scope) {
			if (!Firebird.isArray(args)) {
				if (Firebird.isIterable(args)) {
					args = Firebird.Array.clone(args);
				} else {
					args = args !== undefined ? [args] : [];
				}
			}

			return function () {
				var fnArgs = [].concat(args);
				fnArgs.push.apply(fnArgs, arguments);
				return fn.apply(scope || this, fnArgs);
			};
		},
		/**
		 * 创建别名
		 * Create an alias to the provided method property with name `methodName` of `object`.
		 * Note that the execution scope will still be bound to the provided `object` itself.
		 *
		 * @param {Object/Function} object
		 * @param {String} methodName
		 * @return {Function} aliasFn
		 */
		alias: function (object, methodName) {
			return function () {
				return object[methodName].apply(object, arguments);
			};
		},
		/**
		 * Create a "clone" of the provided method. The returned method will call the given
		 * method passing along all arguments and the "this" pointer and return its result.
		 *
		 * @param {Function} method
		 * @return {Function} cloneFn
		 */
		clone: function (method) {
			return function () {
				return method.apply(this, arguments);
			};
		},
		/**
		 * 方法拦截器
		 * Creates an interceptor function. The passed function is called before the original one. If it returns false,
		 * the original one is not called. The resulting function returns the results of the original function.
		 * The passed function is called with the parameters of the original function.
		 * @example
		 * <pre>
		 *     //Example usage:
		 *     <code>
		 *     var sayHi = function(name){
         *         alert('Hi, ' + name);
         *     }
		 *
		 *     sayHi('Fred'); // alerts "Hi, Fred"
		 *
		 *     // create a new function that validates input without
		 *     // directly modifying the original function:
		 *     var sayHiToFriend = Firebird.Function.createInterceptor(sayHi, function(name){
         *         return name == 'Brian';
         *     });
		 *
		 *     sayHiToFriend('Fred');  // no alert
		 *     sayHiToFriend('Brian'); // alerts "Hi, Brian"
		 *     </code>
		 * </pre>
		 * @param {Function} origFn The original function.
		 * @param {Function} newFn The function to call before the original
		 * @param {Object} [scope] The scope (`this` reference) in which the passed function is executed.
		 * **If omitted, defaults to the scope in which the original function is called or the browser window.**
		 * @param {Object} [returnValue=null] The value to return if the passed function return false.
		 * @return {Function} The new function
		 */
		createInterceptor: function (origFn, newFn, scope, returnValue) {
			var method = origFn;
			if (!Firebird.isFunction(newFn)) {
				return origFn;
			} else {
				returnValue = Firebird.isDefined(returnValue) ? returnValue : null;
				return function () {
					var me = this,
						args = arguments;

					newFn.target = me;
					newFn.method = origFn;
					return (newFn.apply(scope || me || Firebird.global, args) !== false) ? origFn.apply(me || Firebird.global, args) : returnValue;
				};
			}
		},
		/**
		 * Creates a delegate (callback) which, when called, executes after a specific delay.
		 *
		 * @param {Function} fn The function which will be called on a delay when the returned function is called.
		 * Optionally, a replacement (or additional) argument list may be specified.
		 * @param {Number} delay The number of milliseconds to defer execution by whenever called.
		 * @param {Object} scope (optional) The scope (`this` reference) used by the function at execution time.
		 * @param {Array} args (optional) Override arguments for the call. (Defaults to the arguments passed by the caller)
		 * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
		 * if a number the args are inserted at the specified position.
		 * @return {Function} A function which, when called, executes the original function after the specified delay.
		 */
		createDelayed: function (fn, delay, scope, args, appendArgs) {
			if (scope || args) {
				fn = Firebird.Function.bind(fn, scope, args, appendArgs);
			}

			return function () {
				var me = this,
					args = Array.prototype.slice.call(arguments);

				setTimeout(function () {
					fn.apply(me, args);
				}, delay);
			};
		},
		/**
		 * Calls this function after the number of millseconds specified, optionally in a specific scope.
		 * @example
		 * <pre>
		 *     //Example usage:
		 *     <code>
		 *     var sayHi = function(name){
         *         alert('Hi, ' + name);
         *     }
		 *
		 *     // executes immediately:
		 *     sayHi('Fred');
		 *
		 *     // executes after 2 seconds:
		 *     Firebird.Function.defer(sayHi, 2000, this, ['Fred']);
		 *
		 *     // this syntax is sometimes useful for deferring
		 *     // execution of an anonymous function:
		 *     Firebird.Function.defer(function(){
         *         alert('Anonymous');
         *     }, 100);
		 *     </code>
		 * </pre>
		 * {@link Firebird#defer Firebird.defer} is alias for {@link Firebird.Function#defer Firebird.Function.defer}
		 *
		 * @param {Function} fn The function to defer.
		 * @param {Number} millis The number of milliseconds for the setTimeout call
		 * (if less than or equal to 0 the function is executed immediately)
		 * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
		 * **If omitted, defaults to the browser window.**
		 * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
		 * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
		 * if a number the args are inserted at the specified position
		 * @return {Number} The timeout id that can be used with clearTimeout
		 */
		defer: function (fn, millis, scope, args, appendArgs) {
			fn = Firebird.Function.bind(fn, scope, args, appendArgs);
			if (millis > 0) {
				return setTimeout(Firebird.supports.TimeoutActualLateness ? function () {
					fn();
				} : fn, millis);
			}
			fn();
			return 0;
		},
		/**
		 * Create a combined function call sequence of the original function + the passed function.
		 * The resulting function returns the results of the original function.
		 * The passed function is called with the parameters of the original function.
		 * @example
		 * <pre>
		 *     <code>
		 * //Example usage:
		 *
		 *     var sayHi = function(name){
         *         alert('Hi, ' + name);
         *     }
		 *
		 *     sayHi('Fred'); // alerts "Hi, Fred"
		 *
		 *     var sayGoodbye = Firebird.Function.createSequence(sayHi, function(name){
         *         alert('Bye, ' + name);
         *     });
		 *
		 *     sayGoodbye('Fred'); // both alerts show
		 *     </code>
		 * </pre>
		 * @param {Function} originalFn The original function.
		 * @param {Function} newFn The function to sequence
		 * @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed.
		 * If omitted, defaults to the scope in which the original function is called or the default global environment object (usually the browser window).
		 * @return {Function} The new function
		 */
		createSequence: function (originalFn, newFn, scope) {
			if (!newFn) {
				return originalFn;
			}
			else {
				return function () {
					var result = originalFn.apply(this, arguments);
					newFn.apply(scope || this, arguments);
					return result;
				};
			}
		},
		/**
		 * Creates a delegate function, optionally with a bound scope which, when called, buffers
		 * the execution of the passed function for the configured number of milliseconds.
		 * If called again within that period, the impending invocation will be canceled, and the
		 * timeout period will begin again.
		 *
		 * @param {Function} fn The function to invoke on a buffered timer.
		 * @param {Number} buffer The number of milliseconds by which to buffer the invocation of the
		 * function.
		 * @param {Object} scope (optional) The scope (`this` reference) in which
		 * the passed function is executed. If omitted, defaults to the scope specified by the caller.
		 * @param {Array} args (optional) Override arguments for the call. Defaults to the arguments
		 * passed by the caller.
		 * @return {Function} A function which invokes the passed function after buffering for the specified time.
		 */
		createBuffered: function (fn, buffer, scope, args) {
			var timerId;

			return function () {
				var callArgs = args || Array.prototype.slice.call(arguments, 0),
					me = scope || this;

				if (timerId) {
					clearTimeout(timerId);
				}

				timerId = setTimeout(function () {
					fn.apply(me, callArgs);
				}, buffer);
			};
		},
		/**
		 * Creates a throttled version of the passed function which, when called repeatedly and
		 * rapidly, invokes the passed function only after a certain interval has elapsed since the
		 * previous invocation.
		 *
		 * This is useful for wrapping functions which may be called repeatedly, such as
		 * a handler of a mouse move event when the processing is expensive.
		 *
		 * @param {Function} fn The function to execute at a regular time interval.
		 * @param {Number} interval The interval **in milliseconds** on which the passed function is executed.
		 * @param {Object} scope (optional) The scope (`this` reference) in which
		 * the passed function is executed. If omitted, defaults to the scope specified by the caller.
		 * @returns {Function} A function which invokes the passed function at the specified interval.
		 */
		createThrottled: function (fn, interval, scope) {
			var lastCallTime, elapsed, lastArgs, timer, execute = function () {
				fn.apply(scope || this, lastArgs);
				lastCallTime = Firebird.Date.now();
			};

			return function () {
				elapsed = Firebird.Date.now() - lastCallTime;
				lastArgs = arguments;

				clearTimeout(timer);
				if (!lastCallTime || (elapsed >= interval)) {
					execute();
				} else {
					timer = setTimeout(execute, interval - elapsed);
				}
			};
		},
		/**
		 * Adds behavior to an existing method that is executed before the
		 * original behavior of the function.
		 * @example
		 * <pre>
		 *     //例子:
		 *     <code>
		 *     var soup = {
         *         contents: [],
         *         add: function(ingredient) {
         *             this.contents.push(ingredient);
         *         }
         *     };
		 *     Firebird.Function.interceptBefore(soup, "add", function(ingredient){
         *         if (!this.contents.length && ingredient !== "water") {
         *             // Always add water to start with
         *             this.contents.push("water");
         *         }
         *     });
		 *     soup.add("onions");
		 *     soup.add("salt");
		 *     soup.contents; // will contain: water, onions, salt
		 *     </code>
		 * </pre>
		 * @param {Object} object The target object
		 * @param {String} methodName Name of the method to override
		 * @param {Function} fn Function with the new behavior.  It will
		 * be called with the same arguments as the original method.  The
		 * return value of this function will be the return value of the
		 * new method.
		 * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.
		 * @return {Function} The new function just created.
		 */
		interceptBefore: function (object, methodName, fn, scope) {
			var method = object[methodName] || Firebird.emptyFn;

			return (object[methodName] = function () {
				var ret = fn.apply(scope || this, arguments);
				method.apply(this, arguments);

				return ret;
			});
		},
		/**
		 * Adds behavior to an existing method that is executed after the
		 * original behavior of the function.
		 * @example
		 * <pre>
		 *     //例子:
		 *     <code>
		 *     var soup = {
         *         contents: [],
         *         add: function(ingredient) {
         *             this.contents.push(ingredient);
         *         }
         *     };
		 *     Firebird.Function.interceptAfter(soup, "add", function(ingredient){
         *         // Always add a bit of extra salt
         *         this.contents.push("salt");
         *     });
		 *     soup.add("water");
		 *     soup.add("onions");
		 *     soup.contents; // will contain: water, salt, onions, salt
		 *     </code>
		 * </pre>
		 * @param {Object} object The target object
		 * @param {String} methodName Name of the method to override
		 * @param {Function} fn Function with the new behavior.  It will
		 * be called with the same arguments as the original method.  The
		 * return value of this function will be the return value of the
		 * new method.
		 * @param {Object} [scope] The scope to execute the interceptor function. Defaults to the object.
		 * @return {Function} The new function just created.
		 */
		interceptAfter: function (object, methodName, fn, scope) {
			var method = object[methodName] || Firebird.emptyFn;

			return (object[methodName] = function () {
				method.apply(this, arguments);
				return fn.apply(scope || this, arguments);
			});
		}
	};

	/**
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.Function#defer
	 */
	Firebird.defer = Firebird.Function.alias(Firebird.Function, 'defer');

	/**
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.Function#pass
	 */
	Firebird.pass = Firebird.Function.alias(Firebird.Function, 'pass');

	/**
	 * @method
	 * @member Firebird
	 * @inheritdoc Firebird.Function#bind
	 */
	Firebird.bind = Firebird.Function.alias(Firebird.Function, 'bind');

// @tag foundation,core
// @require Function.js
// @define Firebird.Object

	/**
	 * @class Firebird.Object
	 *
	 * 一个处理对象的静态方法集合
	 *
	 * @singleton
	 */

	(function () {

// The "constructor" for chain:
		var TemplateClass = function () {
			},
			FirebirdObject = Firebird.Object = {
				/**
				 * Returns a new object with the given object as the prototype chain. This method is
				 * designed to mimic the ECMA standard `Object.create` method and is assigned to that
				 * function when it is available.
				 *
				 * **NOTE** This method does not support the property definitions capability of the
				 * `Object.create` method. Only the first argument is supported.
				 *
				 * @param {Object} object The prototype chain for the new object.
				 */
				chain: Object.create || function (object) {
					TemplateClass.prototype = object;
					var result = new TemplateClass();
					TemplateClass.prototype = null;
					return result;
				},
				/**
				 * Converts a `name` - `value` pair to an array of objects with support for nested structures. Useful to construct
				 * query strings.
				 * @example
				 * <pre>
				 * // 例子:
				 *     <code>
				 *     var objects = Firebird.Object.toQueryObjects('hobbies', ['reading', 'cooking', 'swimming']);
				 *
				 *     // objects then equals:
				 *     [
				 *         { name: 'hobbies', value: 'reading' },
				 *         { name: 'hobbies', value: 'cooking' },
				 *         { name: 'hobbies', value: 'swimming' },
				 *     ];
				 *
				 *     var objects = Firebird.Object.toQueryObjects('dateOfBirth', {
                 *         day: 3,
                 *         month: 8,
                 *         year: 1987,
                 *         extra: {
                 *             hour: 4
                 *             minute: 30
                 *         }
                 *     }, true); // Recursive
				 *
				 *     // objects then equals:
				 *     [
				 *         { name: 'dateOfBirth[day]', value: 3 },
				 *         { name: 'dateOfBirth[month]', value: 8 },
				 *         { name: 'dateOfBirth[year]', value: 1987 },
				 *         { name: 'dateOfBirth[extra][hour]', value: 4 },
				 *         { name: 'dateOfBirth[extra][minute]', value: 30 },
				 *     ];
				 *     </code>
				 * </pre>
				 * @param {String} name
				 * @param {Object/Array} value
				 * @param {Boolean} [recursive=false] True to traverse object recursively
				 * @return {Array}
				 */
				toQueryObjects: function (name, value, recursive) {
					var self = FirebirdObject.toQueryObjects,
						objects = [],
						i, ln;

					if (Firebird.isArray(value)) {
						for (i = 0, ln = value.length; i < ln; i++) {
							if (recursive) {
								objects = objects.concat(self(name + '[' + i + ']', value[i], true));
							} else {
								objects.push({
									name: name,
									value: value[i]
								});
							}
						}
					} else if (Firebird.isObject(value)) {
						for (i in value) {
							if (value.hasOwnProperty(i)) {
								if (recursive) {
									objects = objects.concat(self(name + '[' + i + ']', value[i], true));
								}
								else {
									objects.push({
										name: name,
										value: value[i]
									});
								}
							}
						}
					} else {
						objects.push({
							name: name,
							value: value
						});
					}

					return objects;
				},
				/**
				 * 把一个对象转换成查询字符串
				 * @example
				 * <pre>
				 *     <code>
				 * //Non-recursive:
				 *
				 *     Firebird.Object.toQueryString({foo: 1, bar: 2}); // returns "foo=1&bar=2"
				 *     Firebird.Object.toQueryString({foo: null, bar: 2}); // returns "foo=&bar=2"
				 *     Firebird.Object.toQueryString({'some price': '$300'}); // returns "some%20price=%24300"
				 *     Firebird.Object.toQueryString({date: new Date(2011, 0, 1)}); // returns "date=%222011-01-01T00%3A00%3A00%22"
				 *     Firebird.Object.toQueryString({colors: ['red', 'green', 'blue']}); // returns "colors=red&colors=green&colors=blue"
				 *
				 * //Recursive:
				 *
				 *     Firebird.Object.toQueryString({
                 *         username: '小戴',
                 *         dateOfBirth: {
                 *             day: 1,
                 *             month: 2,
                 *             year: 1982
                 *         },
                 *         hobbies: ['coding', 'eating', 'sleeping', ['nested', 'stuff']]
                 *     }, true); // returns the following string:
				 *
				 *     // "username=%E5%B0%8F%E6%88%B4&dateOfBirth%5Bday%5D=1&dateOfBirth%5Bmonth%5D=2&dateOfBirth%5Byear%5D=1982&hobbies%5B0%5D=coding&hobbies%5B1%5D=eating&hobbies%5B2%5D=sleeping&hobbies%5B3%5D%5B0%5D=nested&hobbies%5B3%5D%5B1%5D=stuff"
				 *     // decodeURIComponent 后:
				 *     // "username=小戴&dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1982&hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&hobbies[3][0]=nested&hobbies[3][1]=stuff"
				 *     </code>
				 * </pre>
				 * @param {Object} object The object to encode
				 * @param {Boolean} [recursive=false] Whether or not to interpret the object in recursive format.
				 * (PHP / Ruby on Rails servers and similar).
				 * @return {String} queryString
				 */
				toQueryString: function (object, recursive) {
					var paramObjects = [],
						params = [],
						i, j, ln, paramObject, value;

					for (i in object) {
						if (object.hasOwnProperty(i)) {
							paramObjects = paramObjects.concat(FirebirdObject.toQueryObjects(i, object[i], recursive));
						}
					}

					for (j = 0, ln = paramObjects.length; j < ln; j++) {
						paramObject = paramObjects[j];
						value = paramObject.value;

						if (Firebird.isEmpty(value)) {
							value = '';
						} else if (Firebird.isDate(value)) {
							value = Firebird.Date.toString(value);
						}

						params.push(encodeURIComponent(paramObject.name) + '=' + encodeURIComponent(String(value)));
					}

					return params.join('&');
				},
				/**
				 * 把一个查询字符串转换成对象
				 * @example
				 * <pre>
				 *     <code>
				 * //Non-recursive:
				 *
				 *     Firebird.Object.fromQueryString("foo=1&bar=2"); // returns {foo: '1', bar: '2'}
				 *     Firebird.Object.fromQueryString("foo=&bar=2"); // returns {foo: null, bar: '2'}
				 *     Firebird.Object.fromQueryString("some%20price=%24300"); // returns {'some price': '$300'}
				 *     Firebird.Object.fromQueryString("colors=red&colors=green&colors=blue"); // returns {colors: ['red', 'green', 'blue']}
				 *
				 * //Recursive:
				 *
				 *     Firebird.Object.fromQueryString(
				 *         "username=小戴&"+
				 *         "dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1982&"+
				 *         "hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&"+
				 *         "hobbies[3][0]=nested&hobbies[3][1]=stuff", true);
				 *
				 *     // returns
				 *     {
                 *         username: '小戴',
                 *         dateOfBirth: {
                 *             day: '1',
                 *             month: '2',
                 *             year: '1982'
                 *         },
                 *         hobbies: ['coding', 'eating', 'sleeping', ['nested', 'stuff']]
                 *     }
				 *     </code>
				 * </pre>
				 * @param {String} queryString The query string to decode
				 * @param {Boolean} [recursive=false] Whether or not to recursively decode the string. This format is supported by
				 * PHP / Ruby on Rails servers and similar.
				 * @return {Object}
				 */
				fromQueryString: function (queryString, recursive) {
					var parts = queryString.replace(/^\?/, '').split('&'),
						object = {},
						temp, components, name, value, i, ln,
						part, j, subLn, matchedKeys, matchedName,
						keys, key, nextKey;

					for (i = 0, ln = parts.length; i < ln; i++) {
						part = parts[i];

						if (part.length > 0) {
							components = part.split('=');
							name = decodeURIComponent(components[0]);
							value = (components[1] !== undefined) ? decodeURIComponent(components[1]) : '';

							if (!recursive) {
								if (object.hasOwnProperty(name)) {
									if (!Firebird.isArray(object[name])) {
										object[name] = [object[name]];
									}

									object[name].push(value);
								}
								else {
									object[name] = value;
								}
							}
							else {
								matchedKeys = name.match(/(\[):?([^\]]*)\]/g);
								matchedName = name.match(/^([^\[]+)/);

								if (!matchedName) {
									firebird.error(new Error('[Firebird.Object.fromQueryString] 不正确的查询字符串, 此部分名称解析失败 "' + part + '"'));
								}

								name = matchedName[0];
								keys = [];

								if (matchedKeys === null) {
									object[name] = value;
									continue;
								}

								for (j = 0, subLn = matchedKeys.length; j < subLn; j++) {
									key = matchedKeys[j];
									key = (key.length === 2) ? '' : key.substring(1, key.length - 1);
									keys.push(key);
								}

								keys.unshift(name);

								temp = object;

								for (j = 0, subLn = keys.length; j < subLn; j++) {
									key = keys[j];

									if (j === subLn - 1) {
										if (Firebird.isArray(temp) && key === '') {
											temp.push(value);
										}
										else {
											temp[key] = value;
										}
									}
									else {
										if (temp[key] === undefined || typeof temp[key] === 'string') {
											nextKey = keys[j + 1];

											temp[key] = (Firebird.isNumeric(nextKey) || nextKey === '') ? [] : {};
										}

										temp = temp[key];
									}
								}
							}
						}
					}

					return object;
				},
				/**
				 * Iterates through an object and invokes the given callback function for each iteration.
				 * The iteration can be stopped by returning `false` in the callback function. 例子:
				 * @example
				 * <pre>
				 *     <code>
				 *     var person = {
                 *         name: '小戴'
                 *         hairColor: '黑色'
                 *         loves: ['吃', '睡', '女人']
                 *     };
				 *
				 *     Firebird.Object.each(person, function(key, value, myself) {
                 *         console.log(key + ":" + value);
                 *
                 *         if (key === 'hairColor') {
                 *             return false; // stop the iteration
                 *         }
                 *     });
				 *     </code>
				 * </pre>
				 * @param {Object} object The object to iterate
				 * @param {Function} fn The callback function.
				 * @param {String} fn.key
				 * @param {Object} fn.value
				 * @param {Object} fn.object The object itself
				 * @param {Object} [scope] The execution scope (`this`) of the callback function
				 */
				each: function (object, fn, scope) {
					for (var property in object) {
						if (object.hasOwnProperty(property)) {
							if (fn.call(scope || object, property, object[property], object) === false) {
								return;
							}
						}
					}
				},
				/**
				 * Merges any number of objects recursively without referencing them or their children.
				 * @example
				 * <pre>
				 *     <code>
				 *     var extjs = {
                 *         companyName: 'Ext JS',
                 *         products: ['Ext JS', 'Ext GWT', 'Ext Designer'],
                 *         isSuperCool: true,
                 *         office: {
                 *             size: 2000,
                 *             location: 'Palo Alto',
                 *             isFun: true
                 *         }
                 *     };
				 *
				 *     var newStuff = {
                 *         companyName: 'Sencha Inc.',
                 *         products: ['Ext JS', 'Ext GWT', 'Ext Designer', 'Sencha Touch', 'Sencha Animator'],
                 *         office: {
                 *             size: 40000,
                 *             location: 'Redwood City'
                 *         }
                 *     };
				 *
				 *     var sencha = Firebird.Object.merge(extjs, newStuff);
				 *
				 *     // extjs and sencha then equals to
				 *     {
                 *         companyName: 'Sencha Inc.',
                 *         products: ['Ext JS', 'Ext GWT', 'Ext Designer', 'Sencha Touch', 'Sencha Animator'],
                 *         isSuperCool: true,
                 *         office: {
                 *             size: 40000,
                 *             location: 'Redwood City',
                 *             isFun: true
                 *         }
                 *     }
				 *     </code>
				 * </pre>
				 * @param {Object} destination The object into which all subsequent objects are merged.
				 * @param {Object...} object Any number of objects to merge into the destination.
				 * @return {Object} merged The destination object with all passed objects merged in.
				 */
				merge: function (destination) {
					var i = 1,
						ln = arguments.length,
						mergeFn = FirebirdObject.merge,
						cloneFn = Firebird.clone,
						object, key, value, sourceKey;

					for (; i < ln; i++) {
						object = arguments[i];

						for (key in object) {
							value = object[key];
							if (value && value.constructor === Object) {
								sourceKey = destination[key];
								if (sourceKey && sourceKey.constructor === Object) {
									mergeFn(sourceKey, value);
								}
								else {
									destination[key] = cloneFn(value);
								}
							}
							else {
								destination[key] = value;
							}
						}
					}

					return destination;
				},
				/**
				 * @private
				 * @param destination
				 */
				mergeIf: function (destination) {
					var i = 1,
						ln = arguments.length,
						cloneFn = Firebird.clone,
						object, key, value;

					for (; i < ln; i++) {
						object = arguments[i];

						for (key in object) {
							if (!(key in destination)) {
								value = object[key];

								if (value && value.constructor === Object) {
									destination[key] = cloneFn(value);
								}
								else {
									destination[key] = value;
								}
							}
						}
					}

					return destination;
				},
				/**
				 * Returns the first matching key corresponding to the given value.
				 * If no matching value is found, null is returned.
				 * @example
				 * <pre>
				 *     <code>
				 *     var person = {
				 *     		name: '小戴',
				 *     		loves: '吃'
				 *     };
				 *
				 *     alert(Firebird.Object.getKey(person, '吃')); // alerts 'loves'
				 *     </code>
				 * </pre>
				 * @param {Object} object
				 * @param {Object} value The value to find
				 */
				getKey: function (object, value) {
					for (var property in object) {
						if (object.hasOwnProperty(property) && object[property] === value) {
							return property;
						}
					}

					return null;
				},
				/**
				 * Gets all values of the given object as an array.
				 * @example
				 * <pre>
				 *     <code>
				 *     var values = Firebird.Object.getValues({
				 *     		name: '小戴',
				 *     		loves: '吃'
				 *     }); // ['小戴', '吃']
				 *     </code>
				 * </pre>
				 * @param {Object} object
				 * @return {Array} An array of values from the object
				 */
				getValues: function (object) {
					var values = [],
						property;

					for (property in object) {
						if (object.hasOwnProperty(property)) {
							values.push(object[property]);
						}
					}

					return values;
				},
				/**
				 * Gets all keys of the given object as an array.
				 * @example
				 * <pre>
				 *     <code>
				 *     var values = Firebird.Object.getKeys({
				 *     		name: '小戴',
				 *     		loves: '吃'
				 *     }); // ['name', 'loves']
				 *     </code>
				 * </pre>
				 * @param {Object} object
				 * @return {String[]} An array of keys from the object
				 * @method
				 */
				getKeys: (typeof Object.keys == 'function')
					? function (object) {
					if (!object) {
						return [];
					}
					return Object.keys(object);
				}
					: function (object) {
					var keys = [],
						property;

					for (property in object) {
						if (object.hasOwnProperty(property)) {
							keys.push(property);
						}
					}

					return keys;
				},
				/**
				 * Gets the total number of this object's own properties
				 * @example
				 * <pre>
				 *     <code>
				 *     var size = Firebird.Object.getSize({
				 *     		name: '小戴',
				 *     		loves: '吃'
				 *     }); // size equals 2
				 *     </code>
				 * </pre>
				 * @param {Object} object
				 * @return {Number} size
				 */
				getSize: function (object) {
					var size = 0,
						property;

					for (property in object) {
						if (object.hasOwnProperty(property)) {
							size++;
						}
					}

					return size;
				},
				/**
				 * Checks if there are any properties on this object.
				 * @param {Object} object
				 * @return {Boolean} `true` if there no properties on the object.
				 */
				isEmpty: function (object) {
					for (var key in object) {
						if (object.hasOwnProperty(key)) {
							return false;
						}
					}
					return true;
				},
				/**
				 * Shallow compares the contents of 2 objects using strict equality. Objects are
				 * considered equal if they both have the same set of properties and the
				 * value for those properties equals the other in the corresponding object.
				 * @example
				 * <pre>
				 *     <code>
				 *     // Returns true
				 *     Firebird.Object.equals({
				 *     		foo: 1,
				 *     		bar: 2
				 *     }, {
				 *     		foo: 1,
				 *     		bar: 2
				 *     });
				 *     </code>
				 * </pre>
				 * @param {Object} object1
				 * @param {Object} object2
				 * @return {Boolean} `true` if the objects are equal.
				 */
				equals: (function () {
					var check = function (o1, o2) {
						var key;

						for (key in o1) {
							if (o1.hasOwnProperty(key)) {
								if (o1[key] !== o2[key]) {
									return false;
								}
							}
						}
						return true;
					};

					return function (object1, object2) {

						// Short circuit if the same object is passed twice
						if (object1 === object2) {
							return true;
						}
						if (object1 && object2) {
							// Do the second check because we could have extra keys in
							// object2 that don't exist in object1.
							return check(object1, object2) && check(object2, object1);
						} else if (!object1 && !object2) {
							return object1 === object2;
						} else {
							return false;
						}
					};
				})(),
				/**
				 * @private
				 */
				classify: function (object) {
					var prototype = object,
						objectProperties = [],
						propertyClassesMap = {},
						objectClass = function () {
							var i = 0,
								ln = objectProperties.length,
								property;

							for (; i < ln; i++) {
								property = objectProperties[i];
								this[property] = new propertyClassesMap[property]();
							}
						},
						key, value;

					for (key in object) {
						if (object.hasOwnProperty(key)) {
							value = object[key];

							if (value && value.constructor === Object) {
								objectProperties.push(key);
								propertyClassesMap[key] = FirebirdObject.classify(value);
							}
						}
					}

					objectClass.prototype = prototype;

					return objectClass;
				}
			};

		/**
		 * A convenient alias method for {@link Firebird.Object#merge}.
		 *
		 * @member Firebird
		 * @method merge
		 * @inheritdoc Firebird.Object#merge
		 */
		Firebird.merge = Firebird.Object.merge;

		/**
		 * @private
		 * @member Firebird
		 */
		Firebird.mergeIf = Firebird.Object.mergeIf;

		/**
		 *
		 * @member Firebird
		 * @method urlEncode
		 * @inheritdoc Firebird.Object#toQueryString
		 * @deprecated 4.0.0 Use {@link Firebird.Object#toQueryString} instead
		 */
		Firebird.urlEncode = function () {
			var args = Firebird.Array.from(arguments),
				prefix = '';

			// Support for the old `pre` argument
			if ((typeof args[1] === 'string')) {
				prefix = args[1] + '&';
				args[1] = false;
			}

			return prefix + FirebirdObject.toQueryString.apply(FirebirdObject, args);
		};

		/**
		 * Alias for {@link Firebird.Object#fromQueryString}.
		 *
		 * @member Firebird
		 * @method urlDecode
		 * @inheritdoc Firebird.Object#fromQueryString
		 * @deprecated 4.0.0 Use {@link Firebird.Object#fromQueryString} instead
		 */
		Firebird.urlDecode = function () {
			return FirebirdObject.fromQueryString.apply(FirebirdObject, arguments);
		};

	}());

// @tag foundation,core
// @require Object.js
// @define Firebird.Date

	/**
	 * @class Firebird.Date
	 * 日期处理类，包含大量的静态方法
	 * 基本的格式化样式参照了PHP的日期解析
	 * A set of useful static methods to deal with date
	 * Note that if Firebird.Date is required and loaded, it will copy all methods / properties to
	 * this object for convenience
	 *
	 * The date parsing and formatting syntax contains a subset of
	 * [PHP's `date()` function](http://www.php.net/date), and the formats that are
	 * supported will provide results equivalent to their PHP versions.
	 *
	 * The following is a list of all currently supported formats:
	 * <pre class="">
	 Format      Description                                                               Example returned values
	 ------      -----------------------------------------------------------------------   -----------------------
	 d         Day of the month, 2 digits with leading zeros                             01 to 31
	 D         A short textual representation of the day of the week                     Mon to Sun
	 j         Day of the month without leading zeros                                    1 to 31
	 l         A full textual representation of the day of the week                      Sunday to Saturday
	 N         ISO-8601 numeric representation of the day of the week                    1 (for Monday) through 7 (for Sunday)
	 S         English ordinal suffix for the day of the month, 2 characters             st, nd, rd or th. Works well with j
	 w         Numeric representation of the day of the week                             0 (for Sunday) to 6 (for Saturday)
	 z         The day of the year (starting from 0)                                     0 to 364 (365 in leap years)
	 W         ISO-8601 week number of year, weeks starting on Monday                    01 to 53
	 F         A full textual representation of a month, such as January or March        January to December
	 m         Numeric representation of a month, with leading zeros                     01 to 12
	 M         A short textual representation of a month                                 Jan to Dec
	 n         Numeric representation of a month, without leading zeros                  1 to 12
	 t         Number of days in the given month                                         28 to 31
	 L         Whether it&#39;s a leap year                                                  1 if it is a leap year, 0 otherwise.
	 o         ISO-8601 year number (identical to (Y), but if the ISO week number (W)    Examples: 1998 or 2004
	 belongs to the previous or next year, that year is used instead)
	 Y         A full numeric representation of a year, 4 digits                         Examples: 1999 or 2003
	 y         A two digit representation of a year                                      Examples: 99 or 03
	 a         Lowercase Ante meridiem and Post meridiem                                 am or pm
	 A         Uppercase Ante meridiem and Post meridiem                                 AM or PM
	 g         12-hour format of an hour without leading zeros                           1 to 12
	 G         24-hour format of an hour without leading zeros                           0 to 23
	 h         12-hour format of an hour with leading zeros                              01 to 12
	 H         24-hour format of an hour with leading zeros                              00 to 23
	 i         Minutes, with leading zeros                                               00 to 59
	 s         Seconds, with leading zeros                                               00 to 59
	 u         Decimal fraction of a second                                              Examples:
	 (minimum 1 digit, arbitrary number of digits allowed)                     001 (i.e. 0.001s) or
	 100 (i.e. 0.100s) or
	 999 (i.e. 0.999s) or
	 999876543210 (i.e. 0.999876543210s)
	 O         Difference to Greenwich time (GMT) in hours and minutes                   Example: +1030
	 P         Difference to Greenwich time (GMT) with colon between hours and minutes   Example: -08:00
	 T         Timezone abbreviation of the machine running the code                     Examples: EST, MDT, PDT ...
	 Z         Timezone offset in seconds (negative if west of UTC, positive if east)    -43200 to 50400
	 c         ISO 8601 date
	 Notes:                                                                    Examples:
	 1) If unspecified, the month / day defaults to the current month / day,   1991 or
	 the time defaults to midnight, while the timezone defaults to the      1992-10 or
	 browser's timezone. If a time is specified, it must include both hours 1993-09-20 or
	 and minutes. The "T" delimiter, seconds, milliseconds and timezone     1994-08-19T16:20+01:00 or
	 are optional.                                                          1995-07-18T17:21:28-02:00 or
	 2) The decimal fraction of a second, if specified, must contain at        1996-06-17T18:22:29.98765+03:00 or
	 least 1 digit (there is no limit to the maximum number                 1997-05-16T19:23:30,12345-0400 or
	 of digits allowed), and may be delimited by either a '.' or a ','      1998-04-15T20:24:31.2468Z or
	 Refer to the examples on the right for the various levels of              1999-03-14T20:24:32Z or
	 date-time granularity which are supported, or see                         2000-02-13T21:25:33
	 http://www.w3.org/TR/NOTE-datetime for more info.                         2001-01-12 22:26:34
	 U         Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)                1193432466 or -2138434463
	 MS        Microsoft AJAX serialized dates                                           \/Date(1238606590509)\/ (i.e. UTC milliseconds since epoch) or
	 \/Date(1238606590509+0800)\/
	 time      A javascript millisecond timestamp                                        1350024476440
	 timestamp A UNIX timestamp (same as U)                                              1350024866
	 </pre>
	 * @example
	 * <pre>
	 *     <code>
	 * // Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
	 *
	 *     // Sample date:
	 *     // 'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
	 *
	 *     var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
	 *     console.log(Firebird.Date.format(dt, 'Y-m-d'));                          // 2007-01-10
	 *     console.log(Firebird.Date.format(dt, 'F j, Y, g:i a'));                  // January 10, 2007, 3:05 pm
	 *     console.log(Firebird.Date.format(dt, 'l, \\t\\he jS \\of F Y h:i:s A')); // Wednesday, the 10th of January 2007 03:05:01 PM
	 *     </code>
	 * Here are some standard date/time patterns that you might find helpful.  They
	 * are not part of the source of Firebird.Date, but to use them you can simply copy this
	 * block of code into any script that is included after Firebird.Date and they will also become
	 * globally available on the Date object.  Feel free to add or remove patterns as needed in your code.
	 *     <code>
	 *     Firebird.Date.patterns = {
     *         ISO8601Long:"Y-m-d H:i:s",
     *         ISO8601Short:"Y-m-d",
     *         ShortDate: "n/j/Y",
     *         LongDate: "l, F d, Y",
     *         FullDateTime: "l, F d, Y g:i:s A",
     *         MonthDay: "F d",
     *         ShortTime: "g:i A",
     *         LongTime: "g:i:s A",
     *         SortableDateTime: "Y-m-d\\TH:i:s",
     *         UniversalSortableDateTime: "Y-m-d H:i:sO",
     *         YearMonth: "F, Y"
     *     };
	 *     </code>
	 * // Example usage:
	 *     <code>
	 *     var dt = new Date();
	 *     console.log(Firebird.Date.format(dt, Firebird.Date.patterns.ShortDate));
	 *     </code>
	 * </pre>
	 * Developer-written, custom formats may be used by supplying both a formatting and a parsing function
	 * which perform to specialized requirements. The functions are stored in {@link #parseFunctions} and {@link #formatFunctions}.
	 * @singleton
	 */

	/*
	 * Most of the date-formatting functions below are the excellent work of Baron Schwartz.
	 * (see http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/)
	 * They generate precompiled functions from format patterns instead of parsing and
	 * processing each pattern every time a date is formatted. These functions are available
	 * on every Date object.
	 */

// 	Firebird.Date = new function () {
// 		var utilDate = this,
// 			stripEscapeRe = /(\\.)/g,
// 			hourInfoRe = /([gGhHisucUOPZ]|MS)/,
// 			dateInfoRe = /([djzmnYycU]|MS)/,
// 			slashRe = /\\/gi,
// 			numberTokenRe = /\{(\d+)\}/g,
// 			MSFormatRe = new RegExp('\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/'),
// 			code = [
// 				// date calculations (note: the code below creates a dependency on Firebird.Number.from())
// 				"var me = this, dt, y, m, d, h, i, s, ms, o, O, z, zz, u, v, W, year, jan4, week1monday, daysInMonth, dayMatched,",
// 				"def = me.defaults,",
// 				"from = Firebird.Number.from,",
// 				"results = String(input).match(me.parseRegexes[{0}]);", // either null, or an array of matched strings
//
// 				"if(results){",
// 				"{1}",
// 				"if(u != null){", // i.e. unix time is defined
// 				"v = new Date(u * 1000);", // give top priority to UNIX time
// 				"}else{",
// 				// create Date object representing midnight of the current day;
// 				// this will provide us with our date defaults
// 				// (note: clearTime() handles Daylight Saving Time automatically)
// 				"dt = me.clearTime(new Date);",
// 				"y = from(y, from(def.y, dt.getFullYear()));",
// 				"m = from(m, from(def.m - 1, dt.getMonth()));",
// 				"dayMatched = d !== undefined;",
// 				"d = from(d, from(def.d, dt.getDate()));",
// 				// Attempt to validate the day. Since it defaults to today, it may go out
// 				// of range, for example parsing m/Y where the value is 02/2000 on the 31st of May.
// 				// It will attempt to parse 2000/02/31, which will overflow to March and end up
// 				// returning 03/2000. We only do this when we default the day. If an invalid day value
// 				// was set to be parsed by the user, continue on and either let it overflow or return null
// 				// depending on the strict value. This will be in line with the normal Date behaviour.
//
// 				"if (!dayMatched) {",
// 				"dt.setDate(1);",
// 				"dt.setMonth(m);",
// 				"dt.setFullYear(y);",
// 				"daysInMonth = me.getDaysInMonth(dt);",
// 				"if (d > daysInMonth) {",
// 				"d = daysInMonth;",
// 				"}",
// 				"}",
// 				"h  = from(h, from(def.h, dt.getHours()));",
// 				"i  = from(i, from(def.i, dt.getMinutes()));",
// 				"s  = from(s, from(def.s, dt.getSeconds()));",
// 				"ms = from(ms, from(def.ms, dt.getMilliseconds()));",
// 				"if(z >= 0 && y >= 0){",
// 				// both the year and zero-based day of year are defined and >= 0.
// 				// these 2 values alone provide sufficient info to create a full date object
//
// 				// create Date object representing January 1st for the given year
// 				// handle years < 100 appropriately
// 				"v = me.add(new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms), me.YEAR, y < 100 ? y - 100 : 0);",
// 				// then add day of year, checking for Date "rollover" if necessary
// 				"v = !strict? v : (strict === true && (z <= 364 || (me.isLeapYear(v) && z <= 365))? me.add(v, me.DAY, z) : null);",
// 				"}else if(strict === true && !me.isValid(y, m + 1, d, h, i, s, ms)){", // check for Date "rollover"
// 				"v = null;", // invalid date, so return null
// 				"}else{",
// 				"if (W) {", // support ISO-8601
// 				// http://en.wikipedia.org/wiki/ISO_week_date
// 				//
// 				// Mutually equivalent definitions for week 01 are:
// 				// a. the week starting with the Monday which is nearest in time to 1 January
// 				// b. the week with 4 January in it
// 				// ... there are many others ...
// 				//
// 				// We'll use letter b above to determine the first week of the year.
// 				//
// 				// So, first get a Date object for January 4th of whatever calendar year is desired.
// 				//
// 				// Then, the first Monday of the year can easily be determined by (operating on this Date):
// 				// 1. Getting the day of the week.
// 				// 2. Subtracting that by one.
// 				// 3. Multiplying that by 86400000 (one day in ms).
// 				// 4. Subtracting this number of days (in ms) from the January 4 date (represented in ms).
// 				//
// 				// Example #1 ...
// 				//
// 				//       January 2012
// 				//   Su Mo Tu We Th Fr Sa
// 				//    1  2  3  4  5  6  7
// 				//    8  9 10 11 12 13 14
// 				//   15 16 17 18 19 20 21
// 				//   22 23 24 25 26 27 28
// 				//   29 30 31
// 				//
// 				// 1. January 4th is a Wednesday.
// 				// 2. Its day number is 3.
// 				// 3. Simply substract 2 days from Wednesday.
// 				// 4. The first week of the year begins on Monday, January 2. Simple!
// 				//
// 				// Example #2 ...
// 				//       January 1992
// 				//   Su Mo Tu We Th Fr Sa
// 				//             1  2  3  4
// 				//    5  6  7  8  9 10 11
// 				//   12 13 14 15 16 17 18
// 				//   19 20 21 22 23 24 25
// 				//   26 27 28 29 30 31
// 				//
// 				// 1. January 4th is a Saturday.
// 				// 2. Its day number is 6.
// 				// 3. Simply subtract 5 days from Saturday.
// 				// 4. The first week of the year begins on Monday, December 30. Simple!
// 				//
// 				// v = Firebird.Date.clearTime(new Date(week1monday.getTime() + ((W - 1) * 604800000)));
// 				// (This is essentially doing the same thing as above but for the week rather than the day)
// 				"year = y || (new Date()).getFullYear(),",
// 				"jan4 = new Date(year, 0, 4, 0, 0, 0),",
// 				"week1monday = new Date(jan4.getTime() - ((jan4.getDay() - 1) * 86400000));",
// 				"v = Firebird.Date.clearTime(new Date(week1monday.getTime() + ((W - 1) * 604800000)));",
// 				"} else {",
// 				// plain old Date object
// 				// handle years < 100 properly
// 				"v = me.add(new Date(y < 100 ? 100 : y, m, d, h, i, s, ms), me.YEAR, y < 100 ? y - 100 : 0);",
// 				"}",
// 				"}",
// 				"}",
// 				"}",
// 				"if(v){",
// 				// favor UTC offset over GMT offset
// 				"if(zz != null){",
// 				// reset to UTC, then add offset
// 				"v = me.add(v, me.SECOND, -v.getTimezoneOffset() * 60 - zz);",
// 				"}else if(o){",
// 				// reset to GMT, then add offset
// 				"v = me.add(v, me.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
// 				"}",
// 				"}",
// 				"return v;"
// 			].join('\n');
//
// 		// create private copy of Firebird JS's `Firebird.util.Format.format()` method
// 		// - to remove unnecessary dependency
// 		// - to resolve namespace conflict with MS-Ajax's implementation
// 		function xf(format) {
// 			var args = Array.prototype.slice.call(arguments, 1);
// 			return format.replace(numberTokenRe, function (m, i) {
// 				return args[i];
// 			});
// 		}
//
// 		Firebird.apply(utilDate, {
// 			/**
// 			 * Returns the current timestamp.
// 			 * @return {Number} Milliseconds since UNIX epoch.
// 			 * @method
// 			 */
// 			now: Date.now || function () {
// 				return +new Date();
// 			},
// 			/**
// 			 * @private
// 			 * Private for now
// 			 */
// 			toString: function (date) {
// 				var pad = Firebird.String.leftPad;
//
// 				return date.getFullYear() + "-"
// 					+ pad(date.getMonth() + 1, 2, '0') + "-"
// 					+ pad(date.getDate(), 2, '0') + "T"
// 					+ pad(date.getHours(), 2, '0') + ":"
// 					+ pad(date.getMinutes(), 2, '0') + ":"
// 					+ pad(date.getSeconds(), 2, '0');
// 			},
// 			/**
// 			 * Returns the number of milliseconds between two dates.
// 			 * @param {Date} dateA The first date.
// 			 * @param {Date} [dateB=new Date()] (optional) The second date.
// 			 * @return {Number} The difference in milliseconds
// 			 */
// 			getElapsed: function (dateA, dateB) {
// 				return Math.abs(dateA - (dateB || utilDate.now()));
// 			},
// 			/**
// 			 * Global flag which determines if strict date parsing should be used.
// 			 * Strict date parsing will not roll-over invalid dates, which is the
// 			 * default behavior of JavaScript Date objects.
// 			 * (see {@link #parse} for more information)
// 			 * @type Boolean
// 			 */
// 			useStrict: false,
// 			// private
// 			formatCodeToRegex: function (character, currentGroup) {
// 				// Note: currentGroup - position in regex result array (see notes for Firebird.Date.parseCodes below)
// 				var p = utilDate.parseCodes[character];
//
// 				if (p) {
// 					p = typeof p == 'function' ? p() : p;
// 					utilDate.parseCodes[character] = p; // reassign function result to prevent repeated execution
// 				}
//
// 				return p ? Firebird.applyIf({
// 						c: p.c ? xf(p.c, currentGroup || "{0}") : p.c
// 					},
// 					p) : {
// 					g: 0,
// 					c: null,
// 					s: Firebird.String.escapeRegex(character) // treat unrecognized characters as literals
// 				};
// 			},
// 			/**
// 			 * An object hash in which each property is a date parsing function. The property name is the
// 			 * format string which that function parses.
// 			 *
// 			 * This object is automatically populated with date parsing functions as
// 			 * date formats are requested for Firebird standard formatting strings.
// 			 *
// 			 * Custom parsing functions may be inserted into this object, keyed by a name which from then on
// 			 * may be used as a format string to {@link #parse}.
// 			 *
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.parseFunctions['x-date-format'] = myDateParser;
// 			 *
// 			 * A parsing function should return a Date object, and is passed the following parameters:<div class="mdetail-params"><ul>
// 			 * <li><code>date</code> : String<div class="sub-desc">The date string to parse.</div></li>
// 			 * <li><code>strict</code> : Boolean<div class="sub-desc">True to validate date strings while parsing
// 			 * (i.e. prevent JavaScript Date "rollover") (The default must be `false`).
// 			 * Invalid date strings should return `null` when parsed.</div></li>
// 			 * </ul></div>
// 			 *
// 			 * To enable Dates to also be _formatted_ according to that format, a corresponding
// 			 * formatting function must be placed into the {@link #formatFunctions} property.
// 			 * @property parseFunctions
// 			 * @type Object
// 			 */
// 			parseFunctions: {
// 				"MS": function (input, strict) {
// 					// note: the timezone offset is ignored since the MS Ajax server sends
// 					// a UTC milliseconds-since-Unix-epoch value (negative values are allowed)
// 					var r = (input || '').match(MSFormatRe);
// 					return r ? new Date(((r[1] || '') + r[2]) * 1) : null;
// 				},
// 				"time": function (input, strict) {
// 					var num = parseInt(input, 10);
// 					if (num || num === 0) {
// 						return new Date(num);
// 					}
// 					return null;
// 				},
// 				"timestamp": function (input, strict) {
// 					var num = parseInt(input, 10);
// 					if (num || num === 0) {
// 						return new Date(num * 1000);
// 					}
// 					return null;
// 				}
// 			},
// 			parseRegexes: [],
// 			/**
// 			 * An object hash in which each property is a date formatting function. The property name is the
// 			 * format string which corresponds to the produced formatted date string.
// 			 *
// 			 * This object is automatically populated with date formatting functions as
// 			 * date formats are requested for Firebird standard formatting strings.
// 			 *
// 			 * Custom formatting functions may be inserted into this object, keyed by a name which from then on
// 			 * may be used as a format string to {@link #format}.
// 			 *
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.formatFunctions['x-date-format'] = myDateFormatter;
// 			 *
// 			 * A formatting function should return a string representation of the passed Date object, and is passed the following parameters:<div class="mdetail-params"><ul>
// 			 * <li><code>date</code> : Date<div class="sub-desc">The Date to format.</div></li>
// 			 * </ul></div>
// 			 *
// 			 * To enable date strings to also be _parsed_ according to that format, a corresponding
// 			 * parsing function must be placed into the {@link #parseFunctions} property.
// 			 * @property formatFunctions
// 			 * @type Object
// 			 */
// 			formatFunctions: {
// 				"MS": function () {
// 					// UTC milliseconds since Unix epoch (MS-AJAX serialized date format (MRSF))
// 					return '\\/Date(' + this.getTime() + ')\\/';
// 				},
// 				"time": function () {
// 					return this.getTime().toString();
// 				},
// 				"timestamp": function () {
// 					return utilDate.format(this, 'U');
// 				}
// 			},
// 			y2kYear: 50,
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			MILLI: "ms",
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			SECOND: "s",
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			MINUTE: "mi",
// 			/** Date interval constant
// 			 * @type String
// 			 */
// 			HOUR: "h",
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			DAY: "d",
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			MONTH: "mo",
// 			/**
// 			 * Date interval constant
// 			 * @type String
// 			 */
// 			YEAR: "y",
// 			/**
// 			 * An object hash containing default date values used during date parsing.
// 			 *
// 			 * The following properties are available:<div class="mdetail-params"><ul>
// 			 * <li><code>y</code> : Number<div class="sub-desc">The default year value. (defaults to undefined)</div></li>
// 			 * <li><code>m</code> : Number<div class="sub-desc">The default 1-based month value. (defaults to undefined)</div></li>
// 			 * <li><code>d</code> : Number<div class="sub-desc">The default day value. (defaults to undefined)</div></li>
// 			 * <li><code>h</code> : Number<div class="sub-desc">The default hour value. (defaults to undefined)</div></li>
// 			 * <li><code>i</code> : Number<div class="sub-desc">The default minute value. (defaults to undefined)</div></li>
// 			 * <li><code>s</code> : Number<div class="sub-desc">The default second value. (defaults to undefined)</div></li>
// 			 * <li><code>ms</code> : Number<div class="sub-desc">The default millisecond value. (defaults to undefined)</div></li>
// 			 * </ul></div>
// 			 *
// 			 * Override these properties to customize the default date values used by the {@link #parse} method.
// 			 *
// 			 * __Note:__ In countries which experience Daylight Saving Time (i.e. DST), the `h`, `i`, `s`
// 			 * and `ms` properties may coincide with the exact time in which DST takes effect.
// 			 * It is the responsibility of the developer to account for this.
// 			 *
// 			 * // Example Usage:
// 			 *
// 			 *     // set default day value to the first day of the month
// 			 *     Firebird.Date.defaults.d = 1;
// 			 *
// 			 *     // parse a February date string containing only year and month values.
// 			 *     // setting the default day value to 1 prevents weird date rollover issues
// 			 *     // when attempting to parse the following date string on, for example, March 31st 2009.
// 			 *     Firebird.Date.parse('2009-02', 'Y-m'); // returns a Date object representing February 1st 2009
// 			 *
// 			 * @property defaults
// 			 * @type Object
// 			 */
// 			defaults: {},
// 			//<locale type="array">
// 			/**
// 			 * @property {String[]} dayNames
// 			 * An array of textual day names.
// 			 * Override these values for international dates.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.dayNames = [
// 			 *         'SundayInYourLang',
// 			 *         'MondayInYourLang'
// 			 *         // ...
// 			 *     ];
// 			 *     </code>
// 			 * </pre>
// 			 */
// 			dayNames: [
// 				"Sunday",
// 				"Monday",
// 				"Tuesday",
// 				"Wednesday",
// 				"Thursday",
// 				"Friday",
// 				"Saturday"
// 			],
// 			//</locale>
//
// 			//<locale type="array">
// 			/**
// 			 * @property {String[]} monthNames
// 			 * An array of textual month names.
// 			 * Override these values for international dates.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.monthNames = [
// 			 *         'JanInYourLang',
// 			 *         'FebInYourLang'
// 			 *         // ...
// 			 *     ];
// 			 *     </code>
// 			 * </pre>
// 			 */
// 			monthNames: [
// 				"January",
// 				"February",
// 				"March",
// 				"April",
// 				"May",
// 				"June",
// 				"July",
// 				"August",
// 				"September",
// 				"October",
// 				"November",
// 				"December"
// 			],
// 			//</locale>
//
// 			//<locale type="object">
// 			/**
// 			 * @property {Object} monthNumbers
// 			 * An object hash of zero-based JavaScript month numbers (with short month names as keys. **Note:** keys are case-sensitive).
// 			 * Override these values for international dates.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.monthNumbers = {
//              *         'LongJanNameInYourLang': 0,
//              *         'ShortJanNameInYourLang':0,
//              *         'LongFebNameInYourLang':1,
//              *         'ShortFebNameInYourLang':1
//              *         // ...
//              *     };
// 			 *     </code>
// 			 * </pre>
// 			 */
// 			monthNumbers: {
// 				January: 0,
// 				Jan: 0,
// 				February: 1,
// 				Feb: 1,
// 				March: 2,
// 				Mar: 2,
// 				April: 3,
// 				Apr: 3,
// 				May: 4,
// 				June: 5,
// 				Jun: 5,
// 				July: 6,
// 				Jul: 6,
// 				August: 7,
// 				Aug: 7,
// 				September: 8,
// 				Sep: 8,
// 				October: 9,
// 				Oct: 9,
// 				November: 10,
// 				Nov: 10,
// 				December: 11,
// 				Dec: 11
// 			},
// 			//</locale>
//
// 			//<locale>
// 			/**
// 			 * @property {String} defaultFormat
// 			 * The date format string that the {@link Firebird.util.Format#dateRenderer}
// 			 * and {@link Firebird.util.Format#date} functions use.  See {@link Firebird.Date} for details.
// 			 *
// 			 * This may be overridden in a locale file.
// 			 */
// 			defaultFormat: "m/d/Y",
// 			//</locale>
// 			//<locale type="function">
// 			/**
// 			 * 获取月份的短名称
// 			 * Get the short month name for the given month number.
// 			 * Override this function for international dates.
// 			 * @param {Number} month A zero-based JavaScript month number.
// 			 * @return {String} The short month name.
// 			 */
// 			getShortMonthName: function (month) {
// 				return Firebird.Date.monthNames[month].substring(0, 3);
// 			},
// 			//</locale>
//
// 			//<locale type="function">
// 			/**
// 			 * 获取短星期名
// 			 * Get the short day name for the given day number.
// 			 * Override this function for international dates.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 *         Firebird.Date.getShortDayName(1);
// 			 *         // "Mon"
// 			 *         Firebird.Date.getShortDayName(0);
// 			 *         // "Sun"
// 			 *     </code>
// 			 * </pre>
// 			 *
// 			 * @param {Number} day A zero-based JavaScript day number.
// 			 * @return {String} The short day name.
// 			 */
// 			getShortDayName: function (day) {
// 				return Firebird.Date.dayNames[day].substring(0, 3);
// 			},
// 			//</locale>
//
// 			//<locale type="function">
// 			/**
// 			 * 获取月份序号
// 			 * Get the zero-based JavaScript month number for the given short/full month name.
// 			 * Override this function for international dates.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 *         Firebird.Date.getMonthNumber("Oct");
// 			 *         // 9 // 你如果问为什么不是10，请回顾Javascript Date对象
// 			 *     </code>
// 			 * </pre>
// 			 * @param {String} name The short/full month name.
// 			 * @return {Number} The zero-based JavaScript month number.
// 			 */
// 			getMonthNumber: function (name) {
// 				// handle camel casing for English month names (since the keys for the Firebird.Date.monthNumbers hash are case sensitive)
// 				return Firebird.Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
// 			},
// 			//</locale>
//
// 			/**
// 			 * 检查格式化字符串是否有小时信息
// 			 * Checks if the specified format contains hour information
// 			 * @param {String} format The format to check
// 			 * @return {Boolean} True if the format contains hour information
// 			 * @method
// 			 */
// 			formatContainsHourInfo: function (format) {
// 				return hourInfoRe.test(format.replace(stripEscapeRe, ''));
// 			},
// 			/**
// 			 * 检查格式化字符串是否有日期信息
// 			 * Checks if the specified format contains information about
// 			 * anything other than the time.
// 			 * @param {String} format The format to check
// 			 * @return {Boolean} True if the format contains information about
// 			 * date/day information.
// 			 * @method
// 			 */
// 			formatContainsDateInfo: function (format) {
// 				return dateInfoRe.test(format.replace(stripEscapeRe, ''));
// 			},
// 			/**
// 			 * 去除所有
// 			 * Removes all escaping for a date format string. In date formats,
// 			 * using a '\' can be used to escape special characters.
// 			 * @param {String} format The format to unescape
// 			 * @return {String} The unescaped format
// 			 * @method
// 			 */
// 			unescapeFormat: function (format) {
// 				// Escape the format, since \ can be used to escape special
// 				// characters in a date format. 例子, in a Spanish
// 				// locale the format may be: 'd \\de F \\de Y'
// 				return format.replace(slashRe, '');
// 			},
// 			/**
// 			 * 程序预置的可用的格式化代号
// 			 * The base format-code to formatting-function hashmap used by the {@link #format} method.
// 			 * Formatting functions are strings (or functions which return strings) which
// 			 * will return the appropriate value when evaluated in the context of the Date object
// 			 * from which the {@link #format} method is called.
// 			 * Add to / override these mappings for custom date formatting.
// 			 *
// 			 * __Note:__ Firebird.Date.format() treats characters as literals if an appropriate mapping cannot be found.
// 			 *
// 			 * // Example:
// 			 *
// 			 *     Firebird.Date.formatCodes.x = "Firebird.String.leftPad(this.getDate(), 2, '0')";
// 			 *     console.log(Firebird.Date.format(new Date(), 'x')); // returns the current day of the month
// 			 * @type Object
// 			 */
// 			formatCodes: {
// //				yyyy: "this.getFullYear()",
// //				MM: "Firebird.String.leftPad(this.getMonth() + 1, 2, '0')",
// //				dd: "Firebird.String.leftPad(this.getDate(), 2, '0')",
// 				d: "Firebird.String.leftPad(this.getDate(), 2, '0')",
// 				D: "Firebird.Date.getShortDayName(this.getDay())", // get localized short day name
// 				j: "this.getDate()",
// 				l: "Firebird.Date.dayNames[this.getDay()]",
// 				N: "(this.getDay() ? this.getDay() : 7)",
// 				S: "Firebird.Date.getSuffix(this)",
// 				w: "this.getDay()",
// 				z: "Firebird.Date.getDayOfYear(this)",
// 				W: "Firebird.String.leftPad(Firebird.Date.getWeekOfYear(this), 2, '0')",
// 				F: "Firebird.Date.monthNames[this.getMonth()]",
// 				m: "Firebird.String.leftPad(this.getMonth() + 1, 2, '0')",
// 				M: "Firebird.Date.getShortMonthName(this.getMonth())", // get localized short month name
// 				n: "(this.getMonth() + 1)",
// 				t: "Firebird.Date.getDaysInMonth(this)",
// 				L: "(Firebird.Date.isLeapYear(this) ? 1 : 0)",
// 				o: "(this.getFullYear() + (Firebird.Date.getWeekOfYear(this) == 1 && this.getMonth() > 0 ? +1 : (Firebird.Date.getWeekOfYear(this) >= 52 && this.getMonth() < 11 ? -1 : 0)))",
// 				Y: "Firebird.String.leftPad(this.getFullYear(), 4, '0')",
// 				y: "('' + this.getFullYear()).substring(2, 4)",
// 				a: "(this.getHours() < 12 ? 'am' : 'pm')",
// 				A: "(this.getHours() < 12 ? 'AM' : 'PM')",
// 				g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
// 				G: "this.getHours()",
// 				h: "Firebird.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
// 				H: "Firebird.String.leftPad(this.getHours(), 2, '0')",
// 				i: "Firebird.String.leftPad(this.getMinutes(), 2, '0')",
// 				s: "Firebird.String.leftPad(this.getSeconds(), 2, '0')",
// 				u: "Firebird.String.leftPad(this.getMilliseconds(), 3, '0')",
// 				O: "Firebird.Date.getGMTOffset(this)",
// 				P: "Firebird.Date.getGMTOffset(this, true)",
// 				T: "Firebird.Date.getTimezone(this)",
// 				Z: "(this.getTimezoneOffset() * -60)",
// 				c: function () { // ISO-8601 -- GMT format
// 					var c, code, i, l, e;
// 					for (c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
// 						e = c.charAt(i);
// 						code.push(e == "T" ? "'T'" : utilDate.getFormatCode(e)); // treat T as a character literal
// 					}
// 					return code.join(" + ");
// 				},
// 				/*
// 				 c: function() { // ISO-8601 -- UTC format
// 				 return [
// 				 "this.getUTCFullYear()", "'-'",
// 				 "Firebird.util.Format.leftPad(this.getUTCMonth() + 1, 2, '0')", "'-'",
// 				 "Firebird.util.Format.leftPad(this.getUTCDate(), 2, '0')",
// 				 "'T'",
// 				 "Firebird.util.Format.leftPad(this.getUTCHours(), 2, '0')", "':'",
// 				 "Firebird.util.Format.leftPad(this.getUTCMinutes(), 2, '0')", "':'",
// 				 "Firebird.util.Format.leftPad(this.getUTCSeconds(), 2, '0')",
// 				 "'Z'"
// 				 ].join(" + ");
// 				 },
// 				 */
//
// 				U: "Math.round(this.getTime() / 1000)"
// 			},
// 			/**
// 			 * Checks if the passed Date parameters will cause a JavaScript Date "rollover".
// 			 * @param {Number} year 4-digit year
// 			 * @param {Number} month 1-based month-of-year
// 			 * @param {Number} day Day of month
// 			 * @param {Number} hour (optional) Hour
// 			 * @param {Number} minute (optional) Minute
// 			 * @param {Number} second (optional) Second
// 			 * @param {Number} millisecond (optional) Millisecond
// 			 * @return {Boolean} `true` if the passed parameters do not cause a Date "rollover", `false` otherwise.
// 			 */
// 			isValid: function (y, m, d, h, i, s, ms) {
// 				// setup defaults
// 				h = h || 0;
// 				i = i || 0;
// 				s = s || 0;
// 				ms = ms || 0;
//
// 				// Special handling for year < 100
// 				var dt = utilDate.add(new Date(y < 100 ? 100 : y, m - 1, d, h, i, s, ms), utilDate.YEAR, y < 100 ? y - 100 : 0);
//
// 				return y == dt.getFullYear() &&
// 					m == dt.getMonth() + 1 &&
// 					d == dt.getDate() &&
// 					h == dt.getHours() &&
// 					i == dt.getMinutes() &&
// 					s == dt.getSeconds() &&
// 					ms == dt.getMilliseconds();
// 			},
// 			/**
// 			 * 解析字符串，返回一个日期对象
// 			 * Parses the passed string using the specified date format.
// 			 * Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
// 			 * The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
// 			 * which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
// 			 * the current date's year, month, day or DST-adjusted zero-hour time value will be used instead.
// 			 * Keep in mind that the input date string must precisely match the specified format string
// 			 * in order for the parse operation to be successful (failed parse operations return a null value).
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example:
// 			 *
// 			 *     //dt = Fri May 25 2007 (current date)
// 			 *     var dt = new Date();
// 			 *
// 			 *     //dt = Thu May 25 2006 (today&#39;s month/day in 2006)
// 			 *     dt = Firebird.Date.parse("2006", "Y");
// 			 *
// 			 *     //dt = Sun Jan 15 2006 (all date parts specified)
// 			 *     dt = Firebird.Date.parse("2006-01-15", "Y-m-d");
// 			 *
// 			 *     //dt = Sun Jan 15 2006 15:20:01
// 			 *     dt = Firebird.Date.parse("2006-01-15 3:20:01 PM", "Y-m-d g:i:s A");
// 			 *
// 			 *     // attempt to parse Sun Feb 29 2006 03:20:01 in strict mode
// 			 *     dt = Firebird.Date.parse("2006-02-29 03:20:01", "Y-m-d H:i:s", true); // returns null
// 			 *     </code>
// 			 * </pre>
// 			 * @param {String} input The raw date string.
// 			 * @param {String} format The expected date string format.
// 			 * @param {Boolean} [strict=false] (optional) `true` to validate date strings while parsing (i.e. prevents JavaScript Date "rollover").
// 			 * Invalid date strings will return `null` when parsed.
// 			 * @return {Date} The parsed Date.
// 			 */
// 			parse: function (input, format, strict) {
// 				var p = utilDate.parseFunctions;
// 				if (p[format] == null) {
// 					utilDate.createParser(format);
// 				}
// 				return p[format].call(utilDate, input, Firebird.isDefined(strict) ? strict : utilDate.useStrict);
// 			},
// 			// Backwards compat
// 			parseDate: function (input, format, strict) {
// 				return utilDate.parse(input, format, strict);
// 			},
// 			// private
// 			getFormatCode: function (character) {
// 				var f = utilDate.formatCodes[character];
//
// 				if (f) {
// 					f = typeof f == 'function' ? f() : f;
// 					utilDate.formatCodes[character] = f; // reassign function result to prevent repeated execution
// 				}
//
// 				// note: unknown characters are treated as literals
// 				return f || ("'" + Firebird.String.escape(character) + "'");
// 			},
// 			// private
// 			createFormat: function (format) {
// 				var code = [],
// 					special = false,
// 					ch = '',
// 					i;
//
// 				for (i = 0; i < format.length; ++i) {
// 					ch = format.charAt(i);
// 					if (!special && ch == "\\") {
// 						special = true;
// 					} else if (special) {
// 						special = false;
// 						code.push("'" + Firebird.String.escape(ch) + "'");
// 					} else {
// 						code.push(utilDate.getFormatCode(ch));
// 					}
// 				}
// 				utilDate.formatFunctions[format] = Firebird.functionFactory("return " + code.join('+'));
// 			},
// 			// private
// 			createParser: function (format) {
// 				var regexNum = utilDate.parseRegexes.length,
// 					currentGroup = 1,
// 					calc = [],
// 					regex = [],
// 					special = false,
// 					ch = "",
// 					i = 0,
// 					len = format.length,
// 					atEnd = [],
// 					obj;
//
// 				for (; i < len; ++i) {
// 					ch = format.charAt(i);
// 					if (!special && ch == "\\") {
// 						special = true;
// 					} else if (special) {
// 						special = false;
// 						regex.push(Firebird.String.escape(ch));
// 					} else {
// 						obj = utilDate.formatCodeToRegex(ch, currentGroup);
// 						currentGroup += obj.g;
// 						regex.push(obj.s);
// 						if (obj.g && obj.c) {
// 							if (obj.calcAtEnd) {
// 								atEnd.push(obj.c);
// 							} else {
// 								calc.push(obj.c);
// 							}
// 						}
// 					}
// 				}
//
// 				calc = calc.concat(atEnd);
//
// 				utilDate.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", 'i');
// 				utilDate.parseFunctions[format] = Firebird.functionFactory("input", "strict", xf(code, regexNum, calc.join('')));
// 			},
// 			// private
// 			parseCodes: {
// 				/*
// 				 * Notes:
// 				 * g = {Number} calculation group (0 or 1. only group 1 contributes to date calculations.)
// 				 * c = {String} calculation method (required for group 1. null for group 0. {0} = currentGroup - position in regex result array)
// 				 * s = {String} regex pattern. all matches are stored in results[], and are accessible by the calculation mapped to 'c'
// 				 */
// 				d: {
// 					g: 1,
// 					c: "d = parseInt(results[{0}], 10);\n",
// 					s: "(3[0-1]|[1-2][0-9]|0[1-9])" // day of month with leading zeroes (01 - 31)
// 				},
// 				j: {
// 					g: 1,
// 					c: "d = parseInt(results[{0}], 10);\n",
// 					s: "(3[0-1]|[1-2][0-9]|[1-9])" // day of month without leading zeroes (1 - 31)
// 				},
// 				D: function () {
// 					for (var a = [], i = 0; i < 7; a.push(utilDate.getShortDayName(i)), ++i)
// 						; // get localised short day names
// 					return {
// 						g: 0,
// 						c: null,
// 						s: "(?:" + a.join("|") + ")"
// 					};
// 				},
// 				l: function () {
// 					return {
// 						g: 0,
// 						c: null,
// 						s: "(?:" + utilDate.dayNames.join("|") + ")"
// 					};
// 				},
// 				N: {
// 					g: 0,
// 					c: null,
// 					s: "[1-7]" // ISO-8601 day number (1 (monday) - 7 (sunday))
// 				},
// 				//<locale type="object" property="parseCodes">
// 				S: {
// 					g: 0,
// 					c: null,
// 					s: "(?:st|nd|rd|th)"
// 				},
// 				//</locale>
// 				w: {
// 					g: 0,
// 					c: null,
// 					s: "[0-6]" // JavaScript day number (0 (sunday) - 6 (saturday))
// 				},
// 				z: {
// 					g: 1,
// 					c: "z = parseInt(results[{0}], 10);\n",
// 					s: "(\\d{1,3})" // day of the year (0 - 364 (365 in leap years))
// 				},
// 				W: {
// 					g: 1,
// 					c: "W = parseInt(results[{0}], 10);\n",
// 					s: "(\\d{2})" // ISO-8601 week number (with leading zero)
// 				},
// 				F: function () {
// 					return {
// 						g: 1,
// 						c: "m = parseInt(me.getMonthNumber(results[{0}]), 10);\n", // get localised month number
// 						s: "(" + utilDate.monthNames.join("|") + ")"
// 					};
// 				},
// 				M: function () {
// 					for (var a = [], i = 0; i < 12; a.push(utilDate.getShortMonthName(i)), ++i)
// 						; // get localised short month names
// 					return Firebird.applyIf({
// 							s: "(" + a.join("|") + ")"
// 						},
// 						utilDate.formatCodeToRegex("F"));
// 				},
// 				m: {
// 					g: 1,
// 					c: "m = parseInt(results[{0}], 10) - 1;\n",
// 					s: "(1[0-2]|0[1-9])" // month number with leading zeros (01 - 12)
// 				},
// 				n: {
// 					g: 1,
// 					c: "m = parseInt(results[{0}], 10) - 1;\n",
// 					s: "(1[0-2]|[1-9])" // month number without leading zeros (1 - 12)
// 				},
// 				t: {
// 					g: 0,
// 					c: null,
// 					s: "(?:\\d{2})" // no. of days in the month (28 - 31)
// 				},
// 				L: {
// 					g: 0,
// 					c: null,
// 					s: "(?:1|0)"
// 				},
// 				o: {
// 					g: 1,
// 					c: "y = parseInt(results[{0}], 10);\n",
// 					s: "(\\d{4})" // ISO-8601 year number (with leading zero)
//
// 				},
// 				Y: {
// 					g: 1,
// 					c: "y = parseInt(results[{0}], 10);\n",
// 					s: "(\\d{4})" // 4-digit year
// 				},
// 				y: {
// 					g: 1,
// 					c: "var ty = parseInt(results[{0}], 10);\n"
// 					+ "y = ty > me.y2kYear ? 1900 + ty : 2000 + ty;\n", // 2-digit year
// 					s: "(\\d{1,2})"
// 				},
// 				/*
// 				 * In the am/pm parsing routines, we allow both upper and lower case
// 				 * even though it doesn't exactly match the spec. It gives much more flexibility
// 				 * in being able to specify case insensitive regexes.
// 				 */
// 				//<locale type="object" property="parseCodes">
// 				a: {
// 					g: 1,
// 					c: "if (/(am)/i.test(results[{0}])) {\n"
// 					+ "if (!h || h == 12) { h = 0; }\n"
// 					+ "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
// 					s: "(am|pm|AM|PM)",
// 					calcAtEnd: true
// 				},
// 				//</locale>
// 				//<locale type="object" property="parseCodes">
// 				A: {
// 					g: 1,
// 					c: "if (/(am)/i.test(results[{0}])) {\n"
// 					+ "if (!h || h == 12) { h = 0; }\n"
// 					+ "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
// 					s: "(AM|PM|am|pm)",
// 					calcAtEnd: true
// 				},
// 				//</locale>
// 				g: {
// 					g: 1,
// 					c: "h = parseInt(results[{0}], 10);\n",
// 					s: "(1[0-2]|[0-9])" //  12-hr format of an hour without leading zeroes (1 - 12)
// 				},
// 				G: {
// 					g: 1,
// 					c: "h = parseInt(results[{0}], 10);\n",
// 					s: "(2[0-3]|1[0-9]|[0-9])" // 24-hr format of an hour without leading zeroes (0 - 23)
// 				},
// 				h: {
// 					g: 1,
// 					c: "h = parseInt(results[{0}], 10);\n",
// 					s: "(1[0-2]|0[1-9])" //  12-hr format of an hour with leading zeroes (01 - 12)
// 				},
// 				H: {
// 					g: 1,
// 					c: "h = parseInt(results[{0}], 10);\n",
// 					s: "(2[0-3]|[0-1][0-9])" //  24-hr format of an hour with leading zeroes (00 - 23)
// 				},
// 				i: {
// 					g: 1,
// 					c: "i = parseInt(results[{0}], 10);\n",
// 					s: "([0-5][0-9])" // minutes with leading zeros (00 - 59)
// 				},
// 				s: {
// 					g: 1,
// 					c: "s = parseInt(results[{0}], 10);\n",
// 					s: "([0-5][0-9])" // seconds with leading zeros (00 - 59)
// 				},
// 				u: {
// 					g: 1,
// 					c: "ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
// 					s: "(\\d+)" // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
// 				},
// 				O: {
// 					g: 1,
// 					c: [
// 						"o = results[{0}];",
// 						"var sn = o.substring(0,1),", // get + / - sign
// 						"hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", // get hours (performs minutes-to-hour conversion also, just in case)
// 						"mn = o.substring(3,5) % 60;", // get minutes
// 						"o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Firebird.String.leftPad(hr, 2, '0') + Firebird.String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs
// 					].join("\n"),
// 					s: "([+-]\\d{4})" // GMT offset in hrs and mins
// 				},
// 				P: {
// 					g: 1,
// 					c: [
// 						"o = results[{0}];",
// 						"var sn = o.substring(0,1),", // get + / - sign
// 						"hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", // get hours (performs minutes-to-hour conversion also, just in case)
// 						"mn = o.substring(4,6) % 60;", // get minutes
// 						"o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Firebird.String.leftPad(hr, 2, '0') + Firebird.String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs
// 					].join("\n"),
// 					s: "([+-]\\d{2}:\\d{2})" // GMT offset in hrs and mins (with colon separator)
// 				},
// 				T: {
// 					g: 0,
// 					c: null,
// 					s: "[A-Z]{1,5}" // timezone abbrev. may be between 1 - 5 chars
// 				},
// 				Z: {
// 					g: 1,
// 					c: "zz = results[{0}] * 1;\n" // -43200 <= UTC offset <= 50400
// 					+ "zz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
// 					s: "([+-]?\\d{1,5})" // leading '+' sign is optional for UTC offset
// 				},
// 				c: function () {
// 					var calc = [],
// 						arr = [
// 							utilDate.formatCodeToRegex("Y", 1), // year
// 							utilDate.formatCodeToRegex("m", 2), // month
// 							utilDate.formatCodeToRegex("d", 3), // day
// 							utilDate.formatCodeToRegex("H", 4), // hour
// 							utilDate.formatCodeToRegex("i", 5), // minute
// 							utilDate.formatCodeToRegex("s", 6), // second
// 							{
// 								c: "ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"
// 							}, // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
// 							{
// 								c: [// allow either "Z" (i.e. UTC) or "-0530" or "+08:00" (i.e. UTC offset) timezone delimiters. assumes local timezone if no timezone is specified
// 									"if(results[8]) {", // timezone specified
// 									"if(results[8] == 'Z'){",
// 									"zz = 0;", // UTC
// 									"}else if (results[8].indexOf(':') > -1){",
// 									utilDate.formatCodeToRegex("P", 8).c, // timezone offset with colon separator
// 									"}else{",
// 									utilDate.formatCodeToRegex("O", 8).c, // timezone offset without colon separator
// 									"}",
// 									"}"
// 								].join('\n')
// 							}
// 						],
// 						i,
// 						l;
//
// 					for (i = 0, l = arr.length; i < l; ++i) {
// 						calc.push(arr[i].c);
// 					}
//
// 					return {
// 						g: 1,
// 						c: calc.join(""),
// 						s: [
// 							arr[0].s, // year (required)
// 							"(?:", "-", arr[1].s, // month (optional)
// 							"(?:", "-", arr[2].s, // day (optional)
// 							"(?:",
// 							"(?:T| )?", // time delimiter -- either a "T" or a single blank space
// 							arr[3].s, ":", arr[4].s, // hour AND minute, delimited by a single colon (optional). MUST be preceded by either a "T" or a single blank space
// 							"(?::", arr[5].s, ")?", // seconds (optional)
// 							"(?:(?:\\.|,)(\\d+))?", // decimal fraction of a second (e.g. ",12345" or ".98765") (optional)
// 							"(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?", // "Z" (UTC) or "-0530" (UTC offset without colon delimiter) or "+08:00" (UTC offset with colon delimiter) (optional)
// 							")?",
// 							")?",
// 							")?"
// 						].join("")
// 					};
// 				},
// 				U: {
// 					g: 1,
// 					c: "u = parseInt(results[{0}], 10);\n",
// 					s: "(-?\\d+)" // leading minus sign indicates seconds before UNIX epoch
// 				}
// 			},
// 			//Old Firebird.Date prototype methods.
// 			// private
// 			dateFormat: function (date, format) {
// 				return utilDate.format(date, format);
// 			},
// 			/**
// 			 * 比较两个时间是否相等
// 			 * Compares if two dates are equal by comparing their values.
// 			 * @param {Date} date1
// 			 * @param {Date} date2
// 			 * @return {Boolean} `true` if the date values are equal
// 			 */
// 			isEqual: function (date1, date2) {
// 				// check we have 2 date objects
// 				if (date1 && date2) {
// 					return (date1.getTime() === date2.getTime());
// 				}
// 				// one or both isn't a date, only equal if both are falsey
// 				return !(date1 || date2);
// 			},
// 			/**
// 			 * 格式化一个给定的时间对象
// 			 * 参考
// 			 *
// 			 * Formats a date given the supplied format string.
// 			 * @param {Date} date The date to format
// 			 * @param {String} format The format string
// 			 * @return {String} The formatted date or an empty string if date parameter is not a JavaScript Date object
// 			 */
// 			format: function (date, format) {
// 				var formatFunctions = utilDate.formatFunctions;
//
// 				if (!Firebird.isDate(date)) {
// 					return '';
// 				}
//
// 				if (formatFunctions[format] == null) {
// 					utilDate.createFormat(format);
// 				}
//
// 				return formatFunctions[format].call(date) + '';
// 			},
// 			/**
// 			 * 获取时区的缩写，如CST, PDT, EDT等，中国为 CST (​China Standard Time)
// 			 * Get the timezone abbreviation of the current date (equivalent to the format specifier 'T').
// 			 *
// 			 * __Note:__ The date string returned by the JavaScript Date object's `toString()` method varies
// 			 * between browsers (e.g. FF vs IE) and system region settings (e.g. IE in Asia vs IE in America).
// 			 * For a given date string e.g. "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)",
// 			 * getTimezone() first tries to get the timezone abbreviation from between a pair of parentheses
// 			 * (which may or may not be present), failing which it proceeds to get the timezone abbreviation
// 			 * from the GMT offset portion of the date string.
// 			 * @param {Date} date The date
// 			 * @return {String} The abbreviated timezone name (e.g. 'CST', 'PDT', 'EDT', 'MPST' ...).
// 			 */
// 			getTimezone: function (date) {
// 				// the following list shows the differences between date strings from different browsers on a WinXP SP2 machine from an Asian locale:
// 				//
// 				// Opera  : "Thu, 25 Oct 2007 22:53:45 GMT+0800" -- shortest (weirdest) date string of the lot
// 				// Safari : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone (same as FF)
// 				// FF     : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone
// 				// IE     : "Thu Oct 25 22:54:35 UTC+0800 2007" -- (Asian system setting) look for 3-4 letter timezone abbrev
// 				// IE     : "Thu Oct 25 17:06:37 PDT 2007" -- (American system setting) look for 3-4 letter timezone abbrev
// 				//
// 				// this crazy regex attempts to guess the correct timezone abbreviation despite these differences.
// 				// step 1: (?:\((.*)\) -- find timezone in parentheses
// 				// step 2: ([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?) -- if nothing was found in step 1, find timezone from timezone offset portion of date string
// 				// step 3: remove all non uppercase characters found in step 1 and 2
// 				return date.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,5})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
// 			},
// 			/**
// 			 * 获取相对于格林威治标准时间的时差，如北京时间一般为 “+0800”
// 			 * Get the offset from GMT of the current date (equivalent to the format specifier 'O').
// 			 * @param {Date} date The date
// 			 * @param {Boolean} [colon=false] (optional) true to separate the hours and minutes with a colon.
// 			 * @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600').
// 			 */
// 			getGMTOffset: function (date, colon) {
// 				var offset = date.getTimezoneOffset();
// 				return (offset > 0 ? "-" : "+")
// 					+ Firebird.String.leftPad(Math.floor(Math.abs(offset) / 60), 2, "0")
// 					+ (colon ? ":" : "")
// 					+ Firebird.String.leftPad(Math.abs(offset % 60), 2, "0");
// 			},
// 			/**
// 			 * 获取日期在年度中的索引
// 			 * Get the numeric day number of the year, adjusted for leap year.
// 			 * @param {Date} date The date
// 			 * @return {Number} 0 to 364 (365 in leap years).
// 			 */
// 			getDayOfYear: function (date) {
// 				var num = 0,
// 					d = Firebird.Date.clone(date),
// 					m = date.getMonth(),
// 					i;
//
// 				for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
// 					num += utilDate.getDaysInMonth(d);
// 				}
// 				return num + date.getDate() - 1;
// 			},
// 			/**
// 			 * 获取周在年度中的索引
// 			 * Get the numeric ISO-8601 week number of the year.
// 			 * (equivalent to the format specifier 'W', but without a leading zero).
// 			 * @param {Date} date The date
// 			 * @return {Number} 1 to 53
// 			 * @method
// 			 */
// 			getWeekOfYear: (function () {
// 				// adapted from http://www.merlyn.demon.co.uk/weekcalc.htm
// 				var ms1d = 864e5, // milliseconds in a day
// 					ms7d = 7 * ms1d; // milliseconds in a week
//
// 				return function (date) { // return a closure so constants get calculated only once
// 					var DC3 = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate() + 3) / ms1d, // an Absolute Day Number
// 						AWN = Math.floor(DC3 / 7), // an Absolute Week Number
// 						Wyr = new Date(AWN * ms7d).getUTCFullYear();
//
// 					return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
// 				};
// 			}()),
// 			/**
// 			 * 检查是否为闰年
// 			 * Checks if the current date falls within a leap year.
// 			 * @param {Date} date The date
// 			 * @return {Boolean} True if the current date falls within a leap year, false otherwise.
// 			 */
// 			isLeapYear: function (date) {
// 				var year = date.getFullYear();
// 				return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
// 			},
// 			/**
// 			 * 获取每月的第一天
// 			 * Get the first day of the current month, adjusted for leap year.  The returned value
// 			 * is the numeric day index within the week (0-6) which can be used in conjunction with
// 			 * the {@link #monthNames} array to retrieve the textual day name.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example:
// 			 *
// 			 *     var dt = new Date('1/10/2007'),
// 			 *         firstDay = Firebird.Date.getFirstDayOfMonth(dt);
// 			 *     console.log(Firebird.Date.dayNames[firstDay]); // output: 'Monday'
// 			 *     </code>
// 			 * </pre>
// 			 * @param {Date} date The date
// 			 * @return {Number} The day number (0-6).
// 			 */
// 			getFirstDayOfMonth: function (date) {
// 				var day = (date.getDay() - (date.getDate() - 1)) % 7;
// 				return (day < 0) ? (day + 7) : day;
// 			},
// 			/**
// 			 * 获取每月的最后一天
// 			 * Get the last day of the current month, adjusted for leap year.  The returned value
// 			 * is the numeric day index within the week (0-6) which can be used in conjunction with
// 			 * the {@link #monthNames} array to retrieve the textual day name.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * //Example:
// 			 *
// 			 *     var dt = new Date('1/10/2007'),
// 			 *         lastDay = Firebird.Date.getLastDayOfMonth(dt);
// 			 *     console.log(Firebird.Date.dayNames[lastDay]); // output: 'Wednesday'
// 			 *     </code>
// 			 * </pre>
// 			 * @param {Date} date The date
// 			 * @return {Number} The day number (0-6).
// 			 */
// 			getLastDayOfMonth: function (date) {
// 				return utilDate.getLastDateOfMonth(date).getDay();
// 			},
// 			/**
// 			 * 获取当前日期对象所在的月份的第一天
// 			 * Get the date of the first day of the month in which this date resides.
// 			 * @param {Date} date The date
// 			 * @return {Date}
// 			 */
// 			getFirstDateOfMonth: function (date) {
// 				return new Date(date.getFullYear(), date.getMonth(), 1);
// 			},
// 			/**
// 			 * 获取当前日期对象所在的月份的最后一天
// 			 * Get the date of the last day of the month in which this date resides.
// 			 * @param {Date} date The date
// 			 * @return {Date}
// 			 */
// 			getLastDateOfMonth: function (date) {
// 				return new Date(date.getFullYear(), date.getMonth(), utilDate.getDaysInMonth(date));
// 			},
// 			/**
// 			 * 获取当前月份天数
// 			 * Get the number of days in the current month, adjusted for leap year.
// 			 * @param {Date} date The date
// 			 * @return {Number} The number of days in the month.
// 			 * @method
// 			 */
// 			getDaysInMonth: (function () {
// 				var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
//
// 				return function (date) { // return a closure for efficiency
// 					var m = date.getMonth();
//
// 					return m == 1 && utilDate.isLeapYear(date) ? 29 : daysInMonth[m];
// 				};
// 			}()),
// 			//<locale type="function">
// 			/**
// 			 * 获取当前日期的英语后缀
// 			 * st=first
// 			 * nd=second
// 			 * rd=third
// 			 * th=4th,5th,6th,7th,8th,9th
// 			 * Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').
// 			 * @param {Date} date The date
// 			 * @return {String} 'st, 'nd', 'rd' or 'th'.
// 			 */
// 			getSuffix: function (date) {
// 				switch (date.getDate()) {
// 					case 1:
// 					case 21:
// 					case 31:
// 						return "st";
// 					case 2:
// 					case 22:
// 						return "nd";
// 					case 3:
// 					case 23:
// 						return "rd";
// 					default:
// 						return "th";
// 				}
// 			},
// 			//</locale>
//
// 			/**
// 			 * 复制日期，创建并返回一个新的日期的实例。
// 			 * Creates and returns a new Date instance with the exact same date value as the called instance.
// 			 * Dates are copied and passed by reference, so if a copied date variable is modified later, the original
// 			 * variable will also be changed.  When the intention is to create a new variable that will not
// 			 * modify the original instance, you should create a clone.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * // Example of correctly cloning a date:
// 			 *
// 			 *     //wrong way:
// 			 *     var orig = new Date('10/1/2006');
// 			 *     var copy = orig;
// 			 *     copy.setDate(5);
// 			 *     console.log(orig);  // returns 'Thu Oct 05 2006'!
// 			 *
// 			 *     //correct way:
// 			 *     var orig = new Date('10/1/2006'),
// 			 *         copy = Firebird.Date.clone(orig);
// 			 *     copy.setDate(5);
// 			 *     console.log(orig);  // returns 'Thu Oct 01 2006'
// 			 *     </code>
// 			 * </pre>
// 			 * @param {Date} date The date.
// 			 * @return {Date} The new Date instance.
// 			 */
// 			clone: function (date) {
// 				return new Date(date.getTime());
// 			},
// 			/**
// 			 * 检查当前日期是否受夏令时影响
// 			 * Checks if the current date is affected by Daylight Saving Time (DST).
// 			 * @param {Date} date The date
// 			 * @return {Boolean} `true` if the current date is affected by DST.
// 			 */
// 			isDST: function (date) {
// 				// adapted from http://sencha.com/forum/showthread.php?p=247172#post247172
// 				// courtesy of @geoffrey.mcgill
// 				return new Date(date.getFullYear(), 0, 1).getTimezoneOffset() != date.getTimezoneOffset();
// 			},
// 			/**
// 			 * 清除时分秒
// 			 * Attempts to clear all time information from this Date by setting the time to midnight of the same day,
// 			 * automatically adjusting for Daylight Saving Time (DST) where applicable.
// 			 *
// 			 * __Note:__ DST timezone information for the browser's host operating system is assumed to be up-to-date.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 *         var s = new Date;
// 			 *         // Tue Jun 17 2014 10:03:06 GMT+0800 (CST)
// 			 *         Firebird.Date.format(Firebird.Date.clearTime(s), 'Y-m-d H:i:s');
// 			 *         // "2014-06-17 00:00:00"
// 			 *         console.log(s);
// 			 *         // Tue Jun 17 2014 00:00:00 GMT+0800 (CST)
// 			 *     </code>
// 			 * </pre>
// 			 *
// 			 *
// 			 * @param {Date} date The date
// 			 * @param {Boolean} [clone=false] `true` to create a clone of this date, clear the time and return it.
// 			 * @return {Date} this or the clone.
// 			 */
// 			clearTime: function (date, clone) {
// 				if (clone) {
// 					return Firebird.Date.clearTime(Firebird.Date.clone(date));
// 				}
//
// 				// get current date before clearing time
// 				var d = date.getDate(),
// 					hr,
// 					c;
//
// 				// clear time
// 				date.setHours(0);
// 				date.setMinutes(0);
// 				date.setSeconds(0);
// 				date.setMilliseconds(0);
//
// 				if (date.getDate() != d) { // account for DST (i.e. day of month changed when setting hour = 0)
// 					// note: DST adjustments are assumed to occur in multiples of 1 hour (this is almost always the case)
// 					// refer to http://www.timeanddate.com/time/aboutdst.html for the (rare) exceptions to this rule
//
// 					// increment hour until cloned date == current date
// 					for (hr = 1, c = utilDate.add(date, Firebird.Date.HOUR, hr); c.getDate() != d; hr++, c = utilDate.add(date, Firebird.Date.HOUR, hr))
// 						;
//
// 					date.setDate(d);
// 					date.setHours(c.getHours());
// 				}
//
// 				return date;
// 			},
// 			/**
// 			 * 一个比较方便的时间计算方法，它会创建并返回一个新的时间对象实例。
// 			 * Provides a convenient method for performing basic date arithmetic. This method
// 			 * does not modify the Date instance being called - it creates and returns
// 			 * a new Date instance containing the resulting date value.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * //Examples:
// 			 *
// 			 *     // Basic usage:
// 			 *     var dt = Firebird.Date.add(new Date('10/29/2006'), Firebird.Date.DAY, 5);
// 			 *     console.log(dt); // returns 'Fri Nov 03 2006 00:00:00'
// 			 *
// 			 *     // Negative values will be subtracted:
// 			 *     var dt2 = Firebird.Date.add(new Date('10/1/2006'), Firebird.Date.DAY, -5);
// 			 *     console.log(dt2); // returns 'Tue Sep 26 2006 00:00:00'
// 			 *
// 			 *      // Decimal values can be used:
// 			 *     var dt3 = Firebird.Date.add(new Date('10/1/2006'), Firebird.Date.DAY, 1.25);
// 			 *     console.log(dt3); // returns 'Mon Oct 02 2006 06:00:00'
// 			 *     </code>
// 			 * </pre>
// 			 * @param {Date} date The date to modify
// 			 * @param {String} interval A valid date interval enum value.
// 			 * @param {Number} value The amount to add to the current date.
// 			 * @return {Date} The new Date instance.
// 			 */
// 			add: function (date, interval, value) {
// 				var d = Firebird.Date.clone(date),
// 					Date = Firebird.Date,
// 					day, decimalValue, base = 0;
// 				if (!interval || value === 0) {
// 					return d;
// 				}
//
// 				decimalValue = value - parseInt(value, 10);
// 				value = parseInt(value, 10);
//
// 				if (value) {
// 					switch (interval.toLowerCase()) {
// 						// See EXTJSIV-7418. We use setTime() here to deal with issues related to
// 						// the switchover that occurs when changing to daylight savings and vice
// 						// versa. setTime() handles this correctly where setHour/Minute/Second/Millisecond
// 						// do not. Let's assume the DST change occurs at 2am and we're incrementing using add
// 						// for 15 minutes at time. When entering DST, we should see:
// 						// 01:30am
// 						// 01:45am
// 						// 03:00am // skip 2am because the hour does not exist
// 						// ...
// 						// Similarly, leaving DST, we should see:
// 						// 01:30am
// 						// 01:45am
// 						// 01:00am // repeat 1am because that's the change over
// 						// 01:30am
// 						// 01:45am
// 						// 02:00am
// 						// ....
// 						//
// 						case Firebird.Date.MILLI:
// 							d.setTime(d.getTime() + value);
// 							break;
// 						case Firebird.Date.SECOND:
// 							d.setTime(d.getTime() + value * 1000);
// 							break;
// 						case Firebird.Date.MINUTE:
// 							d.setTime(d.getTime() + value * 60 * 1000);
// 							break;
// 						case Firebird.Date.HOUR:
// 							d.setTime(d.getTime() + value * 60 * 60 * 1000);
// 							break;
// 						case Firebird.Date.DAY:
// 							d.setDate(d.getDate() + value);
// 							break;
// 						case Firebird.Date.MONTH:
// 							day = date.getDate();
// 							if (day > 28) {
// 								day = Math.min(day, Firebird.Date.getLastDateOfMonth(Firebird.Date.add(Firebird.Date.getFirstDateOfMonth(date), Firebird.Date.MONTH, value)).getDate());
// 							}
// 							d.setDate(day);
// 							d.setMonth(date.getMonth() + value);
// 							break;
// 						case Firebird.Date.YEAR:
// 							day = date.getDate();
// 							if (day > 28) {
// 								day = Math.min(day, Firebird.Date.getLastDateOfMonth(Firebird.Date.add(Firebird.Date.getFirstDateOfMonth(date), Firebird.Date.YEAR, value)).getDate());
// 							}
// 							d.setDate(day);
// 							d.setFullYear(date.getFullYear() + value);
// 							break;
// 					}
// 				}
//
// 				if (decimalValue) {
// 					switch (interval.toLowerCase()) {
// 						case Firebird.Date.MILLI:
// 							base = 1;
// 							break;
// 						case Firebird.Date.SECOND:
// 							base = 1000;
// 							break;
// 						case Firebird.Date.MINUTE:
// 							base = 1000 * 60;
// 							break;
// 						case Firebird.Date.HOUR:
// 							base = 1000 * 60 * 60;
// 							break;
// 						case Firebird.Date.DAY:
// 							base = 1000 * 60 * 60 * 24;
// 							break;
//
// 						case Firebird.Date.MONTH:
// 							day = utilDate.getDaysInMonth(d);
// 							base = 1000 * 60 * 60 * 24 * day;
// 							break;
//
// 						case Firebird.Date.YEAR:
// 							day = (utilDate.isLeapYear(d) ? 366 : 365);
// 							base = 1000 * 60 * 60 * 24 * day;
// 							break;
// 					}
// 					if (base) {
// 						d.setTime(d.getTime() + base * decimalValue);
// 					}
// 				}
//
// 				return d;
// 			},
// 			/**
// 			 * 一个比较方便的时间计算方法，与 Firebird.Date.add 正好相反，它会创建并返回一个新的时间对象实例。
// 			 * Provides a convenient method for performing basic date arithmetic. This method
// 			 * does not modify the Date instance being called - it creates and returns
// 			 * a new Date instance containing the resulting date value.
// 			 * @example
// 			 * <pre>
// 			 *     <code>
// 			 * //Examples:
// 			 *
// 			 *     // Basic usage:
// 			 *     var dt = Firebird.Date.subtract(new Date('10/29/2006'), Firebird.Date.DAY, 5);
// 			 *     console.log(dt); // returns 'Tue Oct 24 2006 00:00:00'
// 			 *
// 			 *     // Negative values will be added:
// 			 *     var dt2 = Firebird.Date.subtract(new Date('10/1/2006'), Firebird.Date.DAY, -5);
// 			 *     console.log(dt2); // returns 'Fri Oct 6 2006 00:00:00'
// 			 *
// 			 *      // Decimal values can be used:
// 			 *     var dt3 = Firebird.Date.subtract(new Date('10/1/2006'), Firebird.Date.DAY, 1.25);
// 			 *     console.log(dt3); // returns 'Fri Sep 29 2006 06:00:00'
// 			 *     </code>
// 			 * </pre>
// 			 * @param {Date} date The date to modify
// 			 * @param {String} interval A valid date interval enum value.
// 			 * @param {Number} value The amount to subtract from the current date.
// 			 * @return {Date} The new Date instance.
// 			 */
// 			subtract: function (date, interval, value) {
// 				return utilDate.add(date, interval, -value);
// 			},
// 			/**
// 			 * 检查当前日期是否在给定的时间区间内
// 			 * Checks if a date falls on or between the given start and end dates.
// 			 * @param {Date} date The date to check
// 			 * @param {Date} start Start date
// 			 * @param {Date} end End date
// 			 * @return {Boolean} `true` if this date falls on or between the given start and end dates.
// 			 */
// 			between: function (date, start, end) {
// 				var t = date.getTime();
// 				return start.getTime() <= t && t <= end.getTime();
// 			},
// 			// 处理日期对象的的原型方法、静态方法，保证兼容
// 			//Maintains compatibility with old static and prototype window.Date methods.
// 			compat: function () {
// 				var nativeDate = window.Date,
// 					p,
// 					statics = ['useStrict', 'formatCodeToRegex', 'parseFunctions', 'parseRegexes', 'formatFunctions', 'y2kYear', 'MILLI', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'MONTH', 'YEAR', 'defaults', 'dayNames', 'monthNames', 'monthNumbers', 'getShortMonthName', 'getShortDayName', 'getMonthNumber', 'formatCodes', 'isValid', 'parseDate', 'getFormatCode', 'createFormat', 'createParser', 'parseCodes'],
// 					proto = ['dateFormat', 'format', 'getTimezone', 'getGMTOffset', 'getDayOfYear', 'getWeekOfYear', 'isLeapYear', 'getFirstDayOfMonth', 'getLastDayOfMonth', 'getDaysInMonth', 'getSuffix', 'clone', 'isDST', 'clearTime', 'add', 'between'],
// 					sLen = statics.length,
// 					pLen = proto.length,
// 					stat, prot, s;
//
// 				//Append statics
// 				for (s = 0; s < sLen; s++) {
// 					stat = statics[s];
// 					nativeDate[stat] = utilDate[stat];
// 				}
//
// 				//Append to prototype
// 				for (p = 0; p < pLen; p++) {
// 					prot = proto[p];
// 					nativeDate.prototype[prot] = function () {
// 						var args = Array.prototype.slice.call(arguments);
// 						args.unshift(this);
// 						return utilDate[prot].apply(utilDate, args);
// 					};
// 				}
// 			}
// 		});
// 	};

// @tag foundation,core
// @require ../lang/Date.js
// @define Firebird.Base

	/**
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 * @class Firebird.Base
	 *
	 * The root of all classes created with {@link Firebird#define}.
	 *
	 * Firebird.Base is the building block of all Firebird classes. All classes in Firebird inherit from Firebird.Base.
	 * All prototype and static members of this class are inherited by all other classes.
	 */
	(function (flexSetter) {

		var noArgs = [],
			Base = function () {
			},
			hookFunctionFactory = function (hookFunction, underriddenFunction, methodName, owningClass) {
				var result = function () {
					var result = this.callParent(arguments);
					hookFunction.apply(this, arguments);
					return result;
				};
				result.$name = methodName;
				result.$owner = owningClass;
				if (underriddenFunction) {
					result.$previous = underriddenFunction.$previous;
					underriddenFunction.$previous = result;
				}
				return result;
			};

		// These static properties will be copied to every newly created class with {@link Firebird#define}
		Firebird.apply(Base, {
			$className: 'Firebird.Base',
			$isClass: true,
			/**
			 * Create a new instance of this Class.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.cool.Class', {
             *         ...
             *     });
			 *
			 *     My.cool.Class.create({
             *         someConfig: true
             *     });
			 *     </code>
			 * </pre>
			 * All parameters are passed to the constructor of the class.
			 *
			 * @return {Object} the created instance.
			 * @static
			 * @inheritable
			 */
			create: function () {
				return Firebird.create.apply(Firebird, [this].concat(Array.prototype.slice.call(arguments, 0)));
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 * @param config
			 */
			extend: function (parent) {
				var parentPrototype = parent.prototype,
					basePrototype, prototype, i, ln, name, statics;

				prototype = this.prototype = Firebird.Object.chain(parentPrototype);
				prototype.self = this;

				this.superclass = prototype.superclass = parentPrototype;

				if (!parent.$isClass) {
					basePrototype = Firebird.Base.prototype;

					for (i in basePrototype) {
						if (i in prototype) {
							prototype[i] = basePrototype[i];
						}
					}
				}

				// Statics inheritance
				statics = parentPrototype.$inheritableStatics;

				if (statics) {
					for (i = 0, ln = statics.length; i < ln; i++) {
						name = statics[i];

						if (!this.hasOwnProperty(name)) {
							this[name] = parent[name];
						}
					}
				}

				if (parent.$onExtended) {
					this.$onExtended = parent.$onExtended.slice();
				}

				prototype.config = new prototype.configClass();
				prototype.initConfigList = prototype.initConfigList.slice();
				prototype.initConfigMap = Firebird.clone(prototype.initConfigMap);
				prototype.configMap = Firebird.Object.chain(prototype.configMap);
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 */
			$onExtended: [],
			/**
			 * @private
			 * @static
			 * @inheritable
			 */
			triggerExtended: function () {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(this, 'Firebird.Base#triggerExtended', arguments);

				var callbacks = this.$onExtended,
					ln = callbacks.length,
					i, callback;

				if (ln > 0) {
					for (i = 0; i < ln; i++) {
						callback = callbacks[i];
						callback.fn.apply(callback.scope || this, arguments);
					}
				}
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 */
			onExtended: function (fn, scope) {
				this.$onExtended.push({
					fn: fn,
					scope: scope
				});

				return this;
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 * @param config
			 */
			addConfig: function (config, fullMerge) {
				var prototype = this.prototype,
					configNameCache = Firebird.Class.configNameCache,
					hasConfig = prototype.configMap,
					initConfigList = prototype.initConfigList,
					initConfigMap = prototype.initConfigMap,
					defaultConfig = prototype.config,
					initializedName, name, value;

				for (name in config) {
					if (config.hasOwnProperty(name)) {
						if (!hasConfig[name]) {
							hasConfig[name] = true;
						}

						value = config[name];

						initializedName = configNameCache[name].initialized;

						if (!initConfigMap[name] && value !== null && !prototype[initializedName]) {
							initConfigMap[name] = true;
							initConfigList.push(name);
						}
					}
				}

				if (fullMerge) {
					Firebird.merge(defaultConfig, config);
				}
				else {
					Firebird.mergeIf(defaultConfig, config);
				}

				prototype.configClass = Firebird.Object.classify(defaultConfig);
			},
			/**
			 * Add / override static properties of this class.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.cool.Class', {
             *         ...
             *     });
			 *
			 *     My.cool.Class.addStatics({
             *         someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
             *         method1: function() { ... },    // My.cool.Class.method1 = function() { ... };
             *         method2: function() { ... }     // My.cool.Class.method2 = function() { ... };
             *     });
			 *     </code>
			 * </pre>
			 * @param {Object} members
			 * @return {Firebird.Base} this
			 * @static
			 * @inheritable
			 */
			addStatics: function (members) {
				var member, name;

				for (name in members) {
					if (members.hasOwnProperty(name)) {
						member = members[name];
						if (typeof member == 'function' && !member.$isClass && member !== Firebird.emptyFn && member !== Firebird.identityFn) {
							member.$owner = this;
							member.$name = name;
							member.displayName = Firebird.getClassName(this) + '.' + name;
						}
						this[name] = member;
					}
				}

				return this;
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 * @param {Object} members
			 */
			addInheritableStatics: function (members) {
				var inheritableStatics,
					hasInheritableStatics,
					prototype = this.prototype,
					name, member;

				inheritableStatics = prototype.$inheritableStatics;
				hasInheritableStatics = prototype.$hasInheritableStatics;

				if (!inheritableStatics) {
					inheritableStatics = prototype.$inheritableStatics = [];
					hasInheritableStatics = prototype.$hasInheritableStatics = {};
				}

				for (name in members) {
					if (members.hasOwnProperty(name)) {
						member = members[name];
						if (typeof member == 'function') {
							member.displayName = Firebird.getClassName(this) + '.' + name;
						}
						this[name] = member;

						if (!hasInheritableStatics[name]) {
							hasInheritableStatics[name] = true;
							inheritableStatics.push(name);
						}
					}
				}

				return this;
			},
			/**
			 * Add methods / properties to the prototype of this class.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.awesome.Cat', {
             *         constructor: function() {
             *             ...
             *         }
             *     });
			 *
			 *      My.awesome.Cat.addMembers({
             *          meow: function() {
             *             alert('Meowww...');
             *          }
             *      });
			 *
			 *      var kitty = new My.awesome.Cat;
			 *      kitty.meow();
			 *     </code>
			 * </pre>
			 * @param {Object} members
			 * @static
			 * @inheritable
			 */
			addMembers: function (members) {
				var prototype = this.prototype,
					enumerables = Firebird.enumerables,
					names = [],
					i, ln, name, member;

				for (name in members) {
					names.push(name);
				}

				if (enumerables) {
					names.push.apply(names, enumerables);
				}

				for (i = 0, ln = names.length; i < ln; i++) {
					name = names[i];

					if (members.hasOwnProperty(name)) {
						member = members[name];

						if (typeof member == 'function' && !member.$isClass && member !== Firebird.emptyFn && member !== Firebird.identityFn) {
							member.$owner = this;
							member.$name = name;
							member.displayName = (this.$className || '') + '#' + name;
						}

						prototype[name] = member;
					}
				}

				return this;
			},
			/**
			 * @private
			 * @static
			 * @inheritable
			 * @param name
			 * @param member
			 */
			addMember: function (name, member) {
				if (typeof member == 'function' && !member.$isClass && member !== Firebird.emptyFn && member !== Firebird.identityFn) {
					member.$owner = this;
					member.$name = name;
					member.displayName = (this.$className || '') + '#' + name;
				}

				this.prototype[name] = member;
				return this;
			},
			/**
			 * Adds members to class.
			 * @static
			 * @inheritable
			 * @deprecated 4.1 Use {@link #addMembers} instead.
			 */
			implement: function () {
				this.addMembers.apply(this, arguments);
			},
			/**
			 * Borrow another class' members to the prototype of this class.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('Bank', {
             *         money: '$$$',
             *         printMoney: function() {
             *             alert('$$$$$$$');
             *         }
             *     });
			 *
			 *     Firebird.define('Thief', {
             *         ...
             *     });
			 *
			 *     Thief.borrow(Bank, ['money', 'printMoney']);
			 *
			 *     var steve = new Thief();
			 *
			 *     alert(steve.money); // alerts '$$$'
			 *     steve.printMoney(); // alerts '$$$$$$$'
			 *     </code>
			 * </pre>
			 * @param {Firebird.Base} fromClass The class to borrow members from
			 * @param {Array/String} members The names of the members to borrow
			 * @return {Firebird.Base} this
			 * @static
			 * @inheritable
			 * @private
			 */
			borrow: function (fromClass, members) {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(this, 'Firebird.Base#borrow', arguments);

				var prototype = this.prototype,
					fromPrototype = fromClass.prototype,
					className = Firebird.getClassName(this),
					i, ln, name, fn, toBorrow;

				members = Firebird.Array.from(members);

				for (i = 0, ln = members.length; i < ln; i++) {
					name = members[i];

					toBorrow = fromPrototype[name];

					if (typeof toBorrow == 'function') {
						fn = Firebird.Function.clone(toBorrow);

						if (className) {
							fn.displayName = className + '#' + name;
						}

						fn.$owner = this;
						fn.$name = name;

						prototype[name] = fn;
					}
					else {
						prototype[name] = toBorrow;
					}
				}

				return this;
			},
			/**
			 * Override members of this class. Overridden methods can be invoked via
			 * {@link Firebird.Base#callParent}.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.Cat', {
             *         constructor: function() {
             *             alert("I'm a cat!");
             *         }
             *     });
			 *
			 *     My.Cat.override({
             *         constructor: function() {
             *             alert("I'm going to be a cat!");
             *
             *             this.callParent(arguments);
             *
             *             alert("Meeeeoooowwww");
             *         }
             *     });
			 *
			 *     var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
			 *                               // alerts "I'm a cat!"
			 *                               // alerts "Meeeeoooowwww"
			 *     </code>
			 * As of 4.1, direct use of this method is deprecated. Use {@link Firebird#define Firebird.define}
			 * instead:
			 *     <code>
			 *     Firebird.define('My.CatOverride', {
             *         override: 'My.Cat',
             *         constructor: function() {
             *             alert("I'm going to be a cat!");
             *
             *             this.callParent(arguments);
             *
             *             alert("Meeeeoooowwww");
             *         }
             *     });
			 *     </code>
			 * </pre>
			 * The above accomplishes the same result but can be managed by the {@link Firebird.Loader}
			 * which can properly order the override and its target class and the build process
			 * can determine whether the override is needed based on the required state of the
			 * target class (My.Cat).
			 *
			 * @param {Object} members The properties to add to this class. This should be
			 * specified as an object literal containing one or more properties.
			 * @return {Firebird.Base} this class
			 * @static
			 * @inheritable
			 * @markdown
			 * @deprecated 4.1.0 Use {@link Firebird#define Firebird.define} instead
			 */
			override: function (members) {
				var me = this,
					enumerables = Firebird.enumerables,
					target = me.prototype,
					cloneFunction = Firebird.Function.clone,
					name, index, member, statics, names, previous;

				if (arguments.length === 2) {
					name = members;
					members = {};
					members[name] = arguments[1];
					enumerables = null;
				}

				do {
					names = []; // clean slate for prototype (1st pass) and static (2nd pass)
					statics = null; // not needed 1st pass, but needs to be cleared for 2nd pass

					for (name in members) { // hasOwnProperty is checked in the next loop...
						if (name == 'statics') {
							statics = members[name];
						} else if (name == 'inheritableStatics') {
							me.addInheritableStatics(members[name]);
						} else if (name == 'config') {
							me.addConfig(members[name], true);
						} else {
							names.push(name);
						}
					}

					if (enumerables) {
						names.push.apply(names, enumerables);
					}

					for (index = names.length; index--;) {
						name = names[index];

						if (members.hasOwnProperty(name)) {
							member = members[name];

							if (typeof member == 'function' && !member.$className && member !== Firebird.emptyFn && member !== Firebird.identityFn) {
								if (typeof member.$owner != 'undefined') {
									member = cloneFunction(member);
								}

								if (me.$className) {
									member.displayName = me.$className + '#' + name;
								}

								member.$owner = me;
								member.$name = name;

								previous = target[name];
								if (previous) {
									member.$previous = previous;
								}
							}

							target[name] = member;
						}
					}

					target = me; // 2nd pass is for statics
					members = statics; // statics will be null on 2nd pass
				} while (members);

				return this;
			},
			// Documented downwards
			callParent: function (args) {
				var method;

				// This code is intentionally inlined for the least number of debugger stepping
				return (method = this.callParent.caller) && (method.$previous ||
					((method = method.$owner ? method : method.caller) &&
					method.$owner.superclass.self[method.$name])).apply(this, args || noArgs);
			},
			// Documented downwards
			callSuper: function (args) {
				var method;

				// This code is intentionally inlined for the least number of debugger stepping
				return (method = this.callSuper.caller) &&
					((method = method.$owner ? method : method.caller) &&
					method.$owner.superclass.self[method.$name]).apply(this, args || noArgs);
			},
			/**
			 * Used internally by the mixins pre-processor
			 * @private
			 * @static
			 * @inheritable
			 */
			mixin: function (name, mixinClass) {
				var me = this,
					mixin = mixinClass.prototype,
					prototype = me.prototype,
					key, statics, i, ln, staticName,
					mixinValue, hookKey, hookFunction;

				if (typeof mixin.onClassMixedIn != 'undefined') {
					mixin.onClassMixedIn.call(mixinClass, me);
				}

				if (!prototype.hasOwnProperty('mixins')) {
					if ('mixins' in prototype) {
						prototype.mixins = Firebird.Object.chain(prototype.mixins);
					}
					else {
						prototype.mixins = {};
					}
				}

				for (key in mixin) {
					mixinValue = mixin[key];
					if (key === 'mixins') {
						Firebird.merge(prototype.mixins, mixinValue);
					}
					else if (key === 'xhooks') {
						for (hookKey in mixinValue) {
							hookFunction = mixinValue[hookKey];

							// Mixed in xhook methods cannot call a parent.
							hookFunction.$previous = Firebird.emptyFn;

							if (prototype.hasOwnProperty(hookKey)) {

								// Pass the hook function, and the existing function which it is to underride.
								// The existing function has its $previous pointer replaced by a closure
								// which calls the hookFunction and then the existing function's original $previous
								hookFunctionFactory(hookFunction, prototype[hookKey], hookKey, me);
							} else {
								// There's no original function, so generate an implementation which calls
								// the hook function. It will not get any $previous pointer.
								prototype[hookKey] = hookFunctionFactory(hookFunction, null, hookKey, me);
							}
						}
					}
					else if (!(key === 'mixinId' || key === 'config') && (prototype[key] === undefined)) {
						prototype[key] = mixinValue;
					}
				}

				// Mixin statics inheritance
				statics = mixin.$inheritableStatics;

				if (statics) {
					for (i = 0, ln = statics.length; i < ln; i++) {
						staticName = statics[i];

						if (!me.hasOwnProperty(staticName)) {
							me[staticName] = mixinClass[staticName];
						}
					}
				}

				if ('config' in mixin) {
					me.addConfig(mixin.config, false);
				}

				prototype.mixins[name] = mixin;
				return me;
			},
			/**
			 * Get the current class' name in string format.
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.cool.Class', {
             *         constructor: function() {
             *             alert(this.self.getName()); // alerts 'My.cool.Class'
             *         }
             *     });
			 *
			 *     My.cool.Class.getName(); // 'My.cool.Class'
			 *     </code>
			 * </pre>
			 * @return {String} className
			 * @static
			 * @inheritable
			 */
			getName: function () {
				return Firebird.getClassName(this);
			},
			/**
			 * Create aliases for existing prototype methods. Example:
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.cool.Class', {
             *         method1: function() { ... },
             *         method2: function() { ... }
             *     });
			 *
			 *     var test = new My.cool.Class();
			 *
			 *     My.cool.Class.createAlias({
             *         method3: 'method1',
             *         method4: 'method2'
             *     });
			 *
			 *     test.method3(); // test.method1()
			 *
			 *     My.cool.Class.createAlias('method5', 'method3');
			 *
			 *     test.method5(); // test.method3() -> test.method1()
			 *     </code>
			 * </pre>
			 *
			 * @param {String/Object} alias The new method name, or an object to set multiple aliases. See
			 * {@link Firebird.Function#flexSetter flexSetter}
			 * @param {String/Object} origin The original method name
			 * @static
			 * @inheritable
			 * @method
			 */
			createAlias: flexSetter(function (alias, origin) {
				this.override(alias, function () {
					return this[origin].apply(this, arguments);
				});
			}),
			/**
			 * @private
			 * @static
			 * @inheritable
			 */
			addXtype: function (xtype) {
				var prototype = this.prototype,
					xtypesMap = prototype.xtypesMap,
					xtypes = prototype.xtypes,
					xtypesChain = prototype.xtypesChain;

				if (!prototype.hasOwnProperty('xtypesMap')) {
					xtypesMap = prototype.xtypesMap = Firebird.merge({}, prototype.xtypesMap || {});
					xtypes = prototype.xtypes = prototype.xtypes ? [].concat(prototype.xtypes) : [];
					xtypesChain = prototype.xtypesChain = prototype.xtypesChain ? [].concat(prototype.xtypesChain) : [];
					prototype.xtype = xtype;
				}

				if (!xtypesMap[xtype]) {
					xtypesMap[xtype] = true;
					xtypes.push(xtype);
					xtypesChain.push(xtype);
					Firebird.ClassManager.setAlias(this, 'widget.' + xtype);
				}

				return this;
			}
		});

		Base.implement({
			/** @private */
			isInstance: true,
			/** @private */
			$className: 'Firebird.Base',
			/** @private */
			configClass: Firebird.emptyFn,
			/** @private */
			initConfigList: [],
			/** @private */
			configMap: {},
			/** @private */
			initConfigMap: {},
			/**
			 * Get the reference to the class from which this object was instantiated. Note that unlike {@link Firebird.Base#self},
			 * `this.statics()` is scope-independent and it always returns the class from which it was called, regardless of what
			 * `this` points to during run-time
			 * @example
			 * <pre>
			 *     <code>
			 *     Firebird.define('My.Cat', {
             *         statics: {
             *             totalCreated: 0,
             *             speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
             *         },
             *
             *         constructor: function() {
             *             var statics = this.statics();
             *
             *             alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
             *                                             // equivalent to: My.Cat.speciesName
             *
             *             alert(this.self.speciesName);   // dependent on 'this'
             *
             *             statics.totalCreated++;
             *         },
             *
             *         clone: function() {
             *             var cloned = new this.self;                      // dependent on 'this'
             *
             *             cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
             *
             *             return cloned;
             *         }
             *     });
			 *
			 *
			 *     Firebird.define('My.SnowLeopard', {
             *         extend: 'My.Cat',
             *
             *         statics: {
             *             speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
             *         },
             *
             *         constructor: function() {
             *             this.callParent();
             *         }
             *     });
			 *
			 *     var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
			 *
			 *     var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
			 *
			 *     var clone = snowLeopard.clone();
			 *     alert(Firebird.getClassName(clone));         // alerts 'My.SnowLeopard'
			 *     alert(clone.groupName);                 // alerts 'Cat'
			 *
			 *     alert(My.Cat.totalCreated);             // alerts 3
			 *     </code>
			 * </pre>
			 *
			 * @protected
			 * @return {Firebird.Class}
			 */
			statics: function () {
				var method = this.statics.caller,
					self = this.self;

				if (!method) {
					return self;
				}

				return method.$owner;
			},
			/**
			 * Call the "parent" method of the current method. That is the method previously
			 * overridden by derivation or by an override (see {@link Firebird#define}).
			 * @example
			 * <pre><code>
			 *      Firebird.define('My.Base', {
             *          constructor: function (x) {
             *              this.x = x;
             *          },
             *
             *          statics: {
             *              method: function (x) {
             *                  return x;
             *              }
             *          }
             *      });
			 *
			 *      Firebird.define('My.Derived', {
             *          extend: 'My.Base',
             *
             *          constructor: function () {
             *              this.callParent([21]);
             *          }
             *      });
			 *
			 *      var obj = new My.Derived();
			 *
			 *      alert(obj.x);  // alerts 21
			 *      </code>
			 * This can be used with an override as follows:
			 *      <code>
			 *      Firebird.define('My.DerivedOverride', {
             *          override: 'My.Derived',
             *
             *          constructor: function (x) {
             *              this.callParent([x*2]); // calls original My.Derived constructor
             *          }
             *      });
			 *
			 *      var obj = new My.Derived();
			 *
			 *      alert(obj.x);  // now alerts 42
			 *      </code>
			 * This also works with static methods.
			 *      <code>
			 *      Firebird.define('My.Derived2', {
             *          extend: 'My.Base',
             *
             *          statics: {
             *              method: function (x) {
             *                  return this.callParent([x*2]); // calls My.Base.method
             *              }
             *          }
             *      });
			 *
			 *      alert(My.Base.method(10);     // alerts 10
			 *      alert(My.Derived2.method(10); // alerts 20
			 *      </code>
			 * Lastly, it also works with overridden static methods.
			 *      <code>
			 *      Firebird.define('My.Derived2Override', {
             *          override: 'My.Derived2',
             *
             *          statics: {
             *              method: function (x) {
             *                  return this.callParent([x*2]); // calls My.Derived2.method
             *              }
             *          }
             *      });
			 *
			 *      alert(My.Derived2.method(10); // now alerts 40
			 *        </code>
			 * </pre>
			 *
			 * To override a method and replace it and also call the superclass method, use
			 * {@link #callSuper}. This is often done to patch a method to fix a bug.
			 *
			 * @protected
			 * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
			 * from the current method, for example: `this.callParent(arguments)`
			 * @return {Object} Returns the result of calling the parent method
			 */
			callParent: function (args) {
				// NOTE: this code is deliberately as few expressions (and no function calls)
				// as possible so that a debugger can skip over this noise with the minimum number
				// of steps. Basically, just hit Step Into until you are where you really wanted
				// to be.
				var method,
					superMethod = (method = this.callParent.caller) && (method.$previous ||
						((method = method.$owner ? method : method.caller) &&
						method.$owner.superclass[method.$name]));

				if (!superMethod) {
					method = this.callParent.caller;
					var parentClass, methodName;

					if (!method.$owner) {
						if (!method.caller) {
							firebird.error(new Error("[callParent] 尝试调用一个被保护的方法是不允许的！"));
						}

						method = method.caller;
					}

					parentClass = method.$owner.superclass;
					methodName = method.$name;

					if (!(methodName in parentClass)) {
						firebird.error(new Error("调用 this.callParent() 时发现没有这个方法 (" + methodName +
							") 在他的父类上 (" + (Firebird.getClassName(parentClass) || 'Object') + ")"));
					}
				}

				return superMethod.apply(this, args || noArgs);
			},
			/**
			 * This method is used by an override to call the superclass method but bypass any
			 * overridden method. This is often done to "patch" a method that contains a bug
			 * but for whatever reason cannot be fixed directly.
			 *
			 * @example
			 * <pre>
			 * Consider:
			 *      <code>
			 *      Firebird.define('Firebird.some.Class', {
             *          method: function () {
             *              console.log('Good');
             *          }
             *      });
			 *
			 *      Firebird.define('Firebird.some.DerivedClass', {
             *          method: function () {
             *              console.log('Bad');
             *
             *              // ... logic but with a bug ...
             *
             *              this.callParent();
             *          }
             *      });
			 *      </code>
			 * To patch the bug in `DerivedClass.method`, the typical solution is to create an
			 * override:
			 *      <code>
			 *      Firebird.define('App.paches.DerivedClass', {
             *          override: 'Firebird.some.DerivedClass',
             *
             *          method: function () {
             *              console.log('Fixed');
             *
             *              // ... logic but with bug fixed ...
             *
             *              this.callSuper();
             *          }
             *      });
			 *        </code>
			 * </pre>
			 *
			 * The patch method cannot use `callParent` to call the superclass `method` since
			 * that would call the overridden method containing the bug. In other words, the
			 * above patch would only produce "Fixed" then "Good" in the console log, whereas,
			 * using `callParent` would produce "Fixed" then "Bad" then "Good".
			 *
			 * @protected
			 * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
			 * from the current method, for example: `this.callSuper(arguments)`
			 * @return {Object} Returns the result of calling the superclass method
			 */
			callSuper: function (args) {
				// NOTE: this code is deliberately as few expressions (and no function calls)
				// as possible so that a debugger can skip over this noise with the minimum number
				// of steps. Basically, just hit Step Into until you are where you really wanted
				// to be.
				var method,
					superMethod = (method = this.callSuper.caller) &&
						((method = method.$owner ? method : method.caller) &&
						method.$owner.superclass[method.$name]);

				if (!superMethod) {
					method = this.callSuper.caller;
					var parentClass, methodName;

					if (!method.$owner) {
						if (!method.caller) {
							firebird.error(new Error("[callSuper] 尝试调用一个被保护的方法是不允许的！"));
						}

						method = method.caller;
					}

					parentClass = method.$owner.superclass;
					methodName = method.$name;

					if (!(methodName in parentClass)) {
						firebird.error(new Error("调用 this.callSuper() 时发现没有这个方法 (" + methodName +
							") 在他的父类上 (" + (Firebird.getClassName(parentClass) || 'Object') + ")"));
					}
				}

				return superMethod.apply(this, args || noArgs);
			},
			/**
			 * @property {Firebird.Class} self
			 *
			 * Get the reference to the current class from which this object was instantiated. Unlike {@link Firebird.Base#statics},
			 * `this.self` is scope-dependent and it's meant to be used for dynamic inheritance. See {@link Firebird.Base#statics}
			 * for a detailed comparison
			 *
			 * @example
			 * <pre><code>
			 *     Firebird.define('My.Cat', {
             *         statics: {
             *             speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
             *         },
             *
             *         constructor: function() {
             *             alert(this.self.speciesName); // dependent on 'this'
             *         },
             *
             *         clone: function() {
             *             return new this.self();
             *         }
             *     });
			 *
			 *
			 *     Firebird.define('My.SnowLeopard', {
             *         extend: 'My.Cat',
             *         statics: {
             *             speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
             *         }
             *     });
			 *
			 *     var cat = new My.Cat();                     // alerts 'Cat'
			 *     var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'
			 *
			 *     var clone = snowLeopard.clone();
			 *     alert(Firebird.getClassName(clone));             // alerts 'My.SnowLeopard'
			 * </code></pre>
			 *
			 * @protected
			 */
			self: Base,
			// Default constructor, simply returns `this`
			constructor: function () {
				return this;
			},
			/**
			 * 初始化配置
			 *
			 * @example
			 * <pre>
			 * // 一个比较有代表性的例子：
			 *     <code>
			 *     Firebird.define('My.awesome.Class', {
             *         // The default config
             *         config: {
             *             name: 'Awesome',
             *             isAwesome: true
             *         },
             *
             *         constructor: function(config) {
             *             this.initConfig(config);
             *         }
             *     });
			 *
			 *     var awesome = new My.awesome.Class({
             *         name: 'Super Awesome'
             *     });
			 *
			 *     alert(awesome.getName()); // 'Super Awesome'
			 *     </code>
			 * </pre>
			 *
			 * @protected
			 * @param {Object} config
			 * @return {Firebird.Base} this
			 */
			initConfig: function (config) {
				var instanceConfig = config,
					configNameCache = Firebird.Class.configNameCache,
					defaultConfig = new this.configClass(),
					defaultConfigList = this.initConfigList,
					hasConfig = this.configMap,
					nameMap, i, ln, name, initializedName;

				this.initConfig = Firebird.emptyFn;

				this.initialConfig = instanceConfig || {};

				this.config = config = (instanceConfig) ? Firebird.merge(defaultConfig, config) : defaultConfig;

				if (instanceConfig) {
					defaultConfigList = defaultConfigList.slice();

					for (name in instanceConfig) {
						if (hasConfig[name]) {
							if (instanceConfig[name] !== null) {
								defaultConfigList.push(name);
								this[configNameCache[name].initialized] = false;
							}
						}
					}
				}

				for (i = 0, ln = defaultConfigList.length; i < ln; i++) {
					name = defaultConfigList[i];
					nameMap = configNameCache[name];
					initializedName = nameMap.initialized;

					if (!this[initializedName]) {
						this[initializedName] = true;
						this[nameMap.set].call(this, config[name]);
					}
				}

				return this;
			},
			/**
			 * @private
			 * @param config
			 */
			hasConfig: function (name) {
				return Boolean(this.configMap[name]);
			},
			/**
			 * @private
			 */
			setConfig: function (config, applyIfNotSet) {
				if (!config) {
					return this;
				}

				var configNameCache = Firebird.Class.configNameCache,
					currentConfig = this.config,
					hasConfig = this.configMap,
					initialConfig = this.initialConfig,
					name, value;

				applyIfNotSet = Boolean(applyIfNotSet);

				for (name in config) {
					if (applyIfNotSet && initialConfig.hasOwnProperty(name)) {
						continue;
					}

					value = config[name];
					currentConfig[name] = value;

					if (hasConfig[name]) {
						this[configNameCache[name].set](value);
					}
				}

				return this;
			},
			/**
			 * @private
			 * @param name
			 */
			getConfig: function (name) {
				var configNameCache = Firebird.Class.configNameCache;

				return this[configNameCache[name].get]();
			},
			/**
			 * Returns the initial configuration passed to constructor when instantiating
			 * this class.
			 * @param {String} [name] Name of the config option to return.
			 * @return {Object/Mixed} The full config object or a single config value
			 * when `name` parameter specified.
			 */
			getInitialConfig: function (name) {
				var config = this.config;

				if (!name) {
					return config;
				}
				else {
					return config[name];
				}
			},
			/**
			 * @private
			 * @param names
			 * @param callback
			 * @param scope
			 */
			onConfigUpdate: function (names, callback, scope) {
				var self = this.self,
					className = self.$className,
					i, ln, name,
					updaterName, updater, newUpdater;

				names = Firebird.Array.from(names);

				scope = scope || this;

				for (i = 0, ln = names.length; i < ln; i++) {
					name = names[i];
					updaterName = 'update' + Firebird.String.capitalize(name);
					updater = this[updaterName] || Firebird.emptyFn;
					newUpdater = function () {
						updater.apply(this, arguments);
						scope[callback].apply(scope, arguments);
					};
					newUpdater.$name = updaterName;
					newUpdater.$owner = self;
					newUpdater.displayName = className + '#' + updaterName;

					this[updaterName] = newUpdater;
				}
			},
			/**
			 * @private
			 */
			destroy: function () {
				this.destroy = Firebird.emptyFn;
			}
		});

		/**
		 * Call the original method that was previously overridden with {@link Firebird.Base#override}
		 *
		 *     Firebird.define('My.Cat', {
         *         constructor: function() {
         *             alert("I'm a cat!");
         *         }
         *     });
		 *
		 *     My.Cat.override({
         *         constructor: function() {
         *             alert("I'm going to be a cat!");
         *
         *             this.callOverridden();
         *
         *             alert("Meeeeoooowwww");
         *         }
         *     });
		 *
		 *     var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
		 *                               // alerts "I'm a cat!"
		 *                               // alerts "Meeeeoooowwww"
		 *
		 * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
		 * from the current method, for example: `this.callOverridden(arguments)`
		 * @return {Object} Returns the result of calling the overridden method
		 * @protected
		 * @deprecated as of 4.1. Use {@link #callParent} instead.
		 */
		Base.prototype.callOverridden = Base.prototype.callParent;

		Firebird.Base = Base;

	}(Firebird.Function.flexSetter));

// @tag foundation,core
// @require Base.js
// @define Firebird.Class

	/**
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 * @class Firebird.Class
	 *
	 * Handles class creation throughout the framework. This is a low level factory that is used by Firebird.ClassManager and generally
	 * should not be used directly. If you choose to use Firebird.Class you will lose out on the namespace, aliasing and depency loading
	 * features made available by Firebird.ClassManager. The only time you would use Firebird.Class directly is to create an anonymous class.
	 *
	 * If you wish to create a class you should use {@link Firebird#define Firebird.define} which aliases
	 * {@link Firebird.ClassManager#create Firebird.ClassManager.create} to enable namespacing and dynamic dependency resolution.
	 *
	 * Firebird.Class is the factory and **not** the superclass of everything. For the base class that **all** Firebird classes inherit
	 * from, see {@link Firebird.Base}.
	 */
	(function () {
		var FirebirdClass,
			Base = Firebird.Base,
			baseStaticMembers = [],
			baseStaticMember, baseStaticMemberLength;

		for (baseStaticMember in Base) {
			if (Base.hasOwnProperty(baseStaticMember)) {
				baseStaticMembers.push(baseStaticMember);
			}
		}

		baseStaticMemberLength = baseStaticMembers.length;

		// Creates a constructor that has nothing extra in its scope chain.
		function makeCtor(className) {
			function constructor() {
				return this.constructor.apply(this, arguments) || null;
			}

			if (className) {
				constructor.displayName = className;
			}
			return constructor;
		}

		/**
		 * @method constructor
		 * Create a new anonymous class.
		 *
		 * @param {Object} data An object represent the properties of this class
		 * @param {Function} onCreated Optional, the callback function to be executed when this class is fully created.
		 * Note that the creation process can be asynchronous depending on the pre-processors used.
		 *
		 * @return {Firebird.Base} The newly created class
		 */
		Firebird.Class = FirebirdClass = function (Class, data, onCreated) {
			if (typeof Class != 'function') {
				onCreated = data;
				data = Class;
				Class = null;
			}

			if (!data) {
				data = {};
			}

			Class = FirebirdClass.create(Class, data);

			FirebirdClass.process(Class, data, onCreated);

			return Class;
		};

		Firebird.apply(FirebirdClass, {
			/**
			 * @private
			 */
			onBeforeCreated: function (Class, data, hooks) {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, '>> Firebird.Class#onBeforeCreated', arguments);

				Class.addMembers(data);

				hooks.onCreated.call(Class, Class);

				Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, '<< Firebird.Class#onBeforeCreated', arguments);
			},
			/**
			 * @private
			 */
			create: function (Class, data) {
				var name, i;

				if (!Class) {
					Class = makeCtor(
						data.$className
					);
				}

				for (i = 0; i < baseStaticMemberLength; i++) {
					name = baseStaticMembers[i];
					Class[name] = Base[name];
				}

				return Class;
			},
			/**
			 * @private
			 */
			process: function (Class, data, onCreated) {
				var preprocessorStack = data.preprocessors || FirebirdClass.defaultPreprocessors,
					registeredPreprocessors = this.preprocessors,
					hooks = {
						onBeforeCreated: this.onBeforeCreated
					},
					preprocessors = [],
					preprocessor, preprocessorsProperties,
					i, ln, j, subLn, preprocessorProperty;

				delete data.preprocessors;

				for (i = 0, ln = preprocessorStack.length; i < ln; i++) {
					preprocessor = preprocessorStack[i];

					if (typeof preprocessor == 'string') {
						preprocessor = registeredPreprocessors[preprocessor];
						preprocessorsProperties = preprocessor.properties;

						if (preprocessorsProperties === true) {
							preprocessors.push(preprocessor.fn);
						}
						else if (preprocessorsProperties) {
							for (j = 0, subLn = preprocessorsProperties.length; j < subLn; j++) {
								preprocessorProperty = preprocessorsProperties[j];

								if (data.hasOwnProperty(preprocessorProperty)) {
									preprocessors.push(preprocessor.fn);
									break;
								}
							}
						}
					}
					else {
						preprocessors.push(preprocessor);
					}
				}

				hooks.onCreated = onCreated ? onCreated : Firebird.emptyFn;
				hooks.preprocessors = preprocessors;

				this.doProcess(Class, data, hooks);
			},
			doProcess: function (Class, data, hooks) {
				var me = this,
					preprocessors = hooks.preprocessors,
					preprocessor = preprocessors.shift(),
					doProcess = me.doProcess;

				for (; preprocessor; preprocessor = preprocessors.shift()) {
					// Returning false signifies an asynchronous preprocessor - it will call doProcess when we can continue
					if (preprocessor.call(me, Class, data, hooks, doProcess) === false) {
						return;
					}
				}
				hooks.onBeforeCreated.apply(me, arguments);
			},
			/** @private */
			preprocessors: {},
			/**
			 * Register a new pre-processor to be used during the class creation process
			 *
			 * @param {String} name The pre-processor's name
			 * @param {Function} fn The callback function to be executed. Typical format:
			 *
			 *     function(cls, data, fn) {
             *         // Your code here
             *
             *         // Execute this when the processing is finished.
             *         // Asynchronous processing is perfectly ok
             *         if (fn) {
             *             fn.call(this, cls, data);
             *         }
             *     });
			 *
			 * @param {Function} fn.cls The created class
			 * @param {Object} fn.data The set of properties passed in {@link Firebird.Class} constructor
			 * @param {Function} fn.fn The callback function that **must** to be executed when this
			 * pre-processor finishes, regardless of whether the processing is synchronous or aynchronous.
			 * @return {Firebird.Class} this
			 * @private
			 * @static
			 */
			registerPreprocessor: function (name, fn, properties, position, relativeTo) {
				if (!position) {
					position = 'last';
				}

				if (!properties) {
					properties = [name];
				}

				this.preprocessors[name] = {
					name: name,
					properties: properties || false,
					fn: fn
				};

				this.setDefaultPreprocessorPosition(name, position, relativeTo);

				return this;
			},
			/**
			 * Retrieve a pre-processor callback function by its name, which has been registered before
			 *
			 * @param {String} name
			 * @return {Function} preprocessor
			 * @private
			 * @static
			 */
			getPreprocessor: function (name) {
				return this.preprocessors[name];
			},
			/**
			 * @private
			 */
			getPreprocessors: function () {
				return this.preprocessors;
			},
			/**
			 * @private
			 */
			defaultPreprocessors: [],
			/**
			 * Retrieve the array stack of default pre-processors
			 * @return {Function[]} defaultPreprocessors
			 * @private
			 * @static
			 */
			getDefaultPreprocessors: function () {
				return this.defaultPreprocessors;
			},
			/**
			 * Set the default array stack of default pre-processors
			 *
			 * @private
			 * @param {Array} preprocessors
			 * @return {Firebird.Class} this
			 * @static
			 */
			setDefaultPreprocessors: function (preprocessors) {
				this.defaultPreprocessors = Firebird.Array.from(preprocessors);

				return this;
			},
			/**
			 * Insert this pre-processor at a specific position in the stack, optionally relative to
			 * any existing pre-processor. 例子:
			 *
			 *     Firebird.Class.registerPreprocessor('debug', function(cls, data, fn) {
             *         // Your code here
             *
             *         if (fn) {
             *             fn.call(this, cls, data);
             *         }
             *     }).setDefaultPreprocessorPosition('debug', 'last');
			 *
			 * @private
			 * @param {String} name The pre-processor name. Note that it needs to be registered with
			 * {@link Firebird.Class#registerPreprocessor registerPreprocessor} before this
			 * @param {String} offset The insertion position. Four possible values are:
			 * 'first', 'last', or: 'before', 'after' (relative to the name provided in the third argument)
			 * @param {String} relativeName
			 * @return {Firebird.Class} this
			 * @static
			 */
			setDefaultPreprocessorPosition: function (name, offset, relativeName) {
				var defaultPreprocessors = this.defaultPreprocessors,
					index;

				if (typeof offset == 'string') {
					if (offset === 'first') {
						defaultPreprocessors.unshift(name);

						return this;
					}
					else if (offset === 'last') {
						defaultPreprocessors.push(name);

						return this;
					}

					offset = (offset === 'after') ? 1 : -1;
				}

				index = Firebird.Array.indexOf(defaultPreprocessors, relativeName);

				if (index !== -1) {
					Firebird.Array.splice(defaultPreprocessors, Math.max(0, index + offset), 0, name);
				}

				return this;
			},
			configNameCache: {},
			getConfigNameMap: function (name) {
				var cache = this.configNameCache,
					map = cache[name],
					capitalizedName;

				if (!map) {
					capitalizedName = name.charAt(0).toUpperCase() + name.substr(1);

					map = cache[name] = {
						internal: name,
						initialized: '_is' + capitalizedName + 'Initialized',
						apply: 'apply' + capitalizedName,
						update: 'update' + capitalizedName,
						'set': 'set' + capitalizedName,
						'get': 'get' + capitalizedName,
						doSet: 'doSet' + capitalizedName,
						changeEvent: name.toLowerCase() + 'change'
					};
				}

				return map;
			}
		});

		/**
		 * @cfg {String} extend
		 * The parent class that this class extends. 例子:
		 *
		 *     Firebird.define('Person', {
         *         say: function(text) { alert(text); }
         *     });
		 *
		 *     Firebird.define('Developer', {
         *         extend: 'Person',
         *         say: function(text) { this.callParent(["print "+text]); }
         *     });
		 */
		FirebirdClass.registerPreprocessor('extend', function (Class, data, hooks) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#extendPreProcessor', arguments);

			var Base = Firebird.Base,
				basePrototype = Base.prototype,
				extend = data.extend,
				Parent, parentPrototype, i;

			delete data.extend;

			if (extend && extend !== Object) {
				Parent = extend;
			}
			else {
				Parent = Base;
			}

			parentPrototype = Parent.prototype;

			if (!Parent.$isClass) {
				for (i in basePrototype) {
					if (!parentPrototype[i]) {
						parentPrototype[i] = basePrototype[i];
					}
				}
			}

			Class.extend(Parent);

			Class.triggerExtended.apply(Class, arguments);

			if (data.onClassExtended) {
				Class.onExtended(data.onClassExtended, Class);
				delete data.onClassExtended;
			}

		}, true);

		/**
		 * @cfg {Object} statics
		 * List of static methods for this class. 例子:
		 *
		 *     Firebird.define('Computer', {
         *          statics: {
         *              factory: function(brand) {
         *                  // 'this' in static methods refer to the class itself
         *                  return new this(brand);
         *              }
         *          },
         *
         *          constructor: function() { ... }
         *     });
		 *
		 *     var dellComputer = Computer.factory('Dell');
		 */
		FirebirdClass.registerPreprocessor('statics', function (Class, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#staticsPreprocessor', arguments);

			Class.addStatics(data.statics);

			delete data.statics;
		});

		/**
		 * @cfg {Object} inheritableStatics
		 * List of inheritable static methods for this class.
		 * Otherwise just like {@link #statics} but subclasses inherit these methods.
		 */
		FirebirdClass.registerPreprocessor('inheritableStatics', function (Class, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#inheritableStaticsPreprocessor', arguments);

			Class.addInheritableStatics(data.inheritableStatics);

			delete data.inheritableStatics;
		});

		/**
		 * @cfg {Object} config
		 * List of configuration options with their default values, for which automatically
		 * accessor methods are generated.  例子:
		 *
		 *     Firebird.define('SmartPhone', {
         *          config: {
         *              hasTouchScreen: false,
         *              operatingSystem: 'Other',
         *              price: 500
         *          },
         *          constructor: function(cfg) {
         *              this.initConfig(cfg);
         *          }
         *     });
		 *
		 *     var iPhone = new SmartPhone({
         *          hasTouchScreen: true,
         *          operatingSystem: 'iOS'
         *     });
		 *
		 *     iPhone.getPrice(); // 500;
		 *     iPhone.getOperatingSystem(); // 'iOS'
		 *     iPhone.getHasTouchScreen(); // true;
		 *
		 * NOTE for when configs are reference types, the getter and setter methods do not make copies.
		 *
		 * 例子, when a config value is set, the reference is stored on the instance. All instances that set
		 * the same reference type will share it.
		 *
		 * In the case of the getter, the value with either come from the prototype if the setter was never called or from
		 * the instance as the last value passed to the setter.
		 *
		 * For some config properties, the value passed to the setter is transformed prior to being stored on the instance.
		 */
		FirebirdClass.registerPreprocessor('config', function (Class, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#configPreProcessor', arguments);

			var config = data.config,
				prototype = Class.prototype;

			delete data.config;

			Firebird.Object.each(config, function (name, value) {
				var nameMap = FirebirdClass.getConfigNameMap(name),
					internalName = nameMap.internal,
					initializedName = nameMap.initialized,
					applyName = nameMap.apply,
					updateName = nameMap.update,
					setName = nameMap.set,
					getName = nameMap.get,
					hasOwnSetter = (setName in prototype) || data.hasOwnProperty(setName),
					hasOwnApplier = (applyName in prototype) || data.hasOwnProperty(applyName),
					hasOwnUpdater = (updateName in prototype) || data.hasOwnProperty(updateName),
					optimizedGetter, customGetter;

				if (value === null || (!hasOwnSetter && !hasOwnApplier && !hasOwnUpdater)) {
					prototype[internalName] = value;
					prototype[initializedName] = true;
				}
				else {
					prototype[initializedName] = false;
				}

				if (!hasOwnSetter) {
					data[setName] = function (value) {
						var oldValue = this[internalName],
							applier = this[applyName],
							updater = this[updateName];

						if (!this[initializedName]) {
							this[initializedName] = true;
						}

						if (applier) {
							value = applier.call(this, value, oldValue);
						}

						if (typeof value != 'undefined') {
							this[internalName] = value;

							if (updater && value !== oldValue) {
								updater.call(this, value, oldValue);
							}
						}

						return this;
					};
				}

				if (!(getName in prototype) || data.hasOwnProperty(getName)) {
					customGetter = data[getName] || false;

					if (customGetter) {
						optimizedGetter = function () {
							return customGetter.apply(this, arguments);
						};
					}
					else {
						optimizedGetter = function () {
							return this[internalName];
						};
					}

					data[getName] = function () {
						var currentGetter;

						if (!this[initializedName]) {
							this[initializedName] = true;
							this[setName](this.config[name]);
						}

						currentGetter = this[getName];

						if ('$previous' in currentGetter) {
							currentGetter.$previous = optimizedGetter;
						}
						else {
							this[getName] = optimizedGetter;
						}

						return optimizedGetter.apply(this, arguments);
					};
				}
			});

			Class.addConfig(config, true);
		});

		/**
		 * @cfg {String[]/Object} mixins
		 * List of classes to mix into this class. 例子:
		 *
		 *     Firebird.define('CanSing', {
         *          sing: function() {
         *              alert("I'm on the highway to hell...")
         *          }
         *     });
		 *
		 *     Firebird.define('Musician', {
         *          mixins: ['CanSing']
         *     })
		 *
		 * In this case the Musician class will get a `sing` method from CanSing mixin.
		 *
		 * But what if the Musician already has a `sing` method? Or you want to mix
		 * in two classes, both of which define `sing`?  In such a cases it's good
		 * to define mixins as an object, where you assign a name to each mixin:
		 *
		 *     Firebird.define('Musician', {
         *          mixins: {
         *              canSing: 'CanSing'
         *          },
         *
         *          sing: function() {
         *              // delegate singing operation to mixin
         *              this.mixins.canSing.sing.call(this);
         *          }
         *     })
		 *
		 * In this case the `sing` method of Musician will overwrite the
		 * mixed in `sing` method. But you can access the original mixed in method
		 * through special `mixins` property.
		 */
		FirebirdClass.registerPreprocessor('mixins', function (Class, data, hooks) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#mixinsPreprocessor', arguments);

			var mixins = data.mixins,
				name, mixin, i, ln;

			delete data.mixins;

			Firebird.Function.interceptBefore(hooks, 'onCreated', function () {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#mixinsPreprocessor#beforeCreated', arguments);

				if (mixins instanceof Array) {
					for (i = 0, ln = mixins.length; i < ln; i++) {
						mixin = mixins[i];
						name = mixin.prototype.mixinId || mixin.$className;

						Class.mixin(name, mixin);
					}
				}
				else {
					for (var mixinName in mixins) {
						if (mixins.hasOwnProperty(mixinName)) {
							Class.mixin(mixinName, mixins[mixinName]);
						}
					}
				}
			});
		});

		// Backwards compatible
		Firebird.extend = function (Class, Parent, members) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(Class, 'Firebird.Class#extend-backwards-compatible', arguments);

			if (arguments.length === 2 && Firebird.isObject(Parent)) {
				members = Parent;
				Parent = Class;
				Class = null;
			}

			var cls;

			if (!Parent) {
				firebird.error(new Error("[Firebird.extend] 尝试继承一个不存在的类。"));
			}

			members.extend = Parent;
			members.preprocessors = [
				'extend'
				, 'statics'
				, 'inheritableStatics'
				, 'mixins'
				, 'config'
			];

			if (Class) {
				cls = new FirebirdClass(Class, members);
				// The 'constructor' is given as 'Class' but also needs to be on prototype
				cls.prototype.constructor = Class;
			} else {
				cls = new FirebirdClass(members);
			}

			cls.prototype.override = function (o) {
				for (var m in o) {
					if (o.hasOwnProperty(m)) {
						this[m] = o[m];
					}
				}
			};

			return cls;
		};
	}());

// @tag foundation,core
// @require Class.js
// @define Firebird.ClassManager

	/**
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 * @class Firebird.ClassManager
	 *
	 * Firebird.ClassManager manages all classes and handles mapping from string class name to
	 * actual class objects throughout the whole framework. It is not generally accessed directly, rather through
	 * these convenient shorthands:
	 *
	 * - {@link Firebird#define Firebird.define}
	 * - {@link Firebird#create Firebird.create}
	 * - {@link Firebird#widget Firebird.widget}
	 * - {@link Firebird#getClass Firebird.getClass}
	 * - {@link Firebird#getClassName Firebird.getClassName}
	 *
	 * # Basic syntax:
	 *
	 *     Firebird.define(className, properties);
	 *
	 * in which `properties` is an object represent a collection of properties that apply to the class. See
	 * {@link Firebird.ClassManager#create} for more detailed instructions.
	 *
	 *     Firebird.define('Person', {
     *          name: 'Unknown',
     *
     *          constructor: function(name) {
     *              if (name) {
     *                  this.name = name;
     *              }
     *          },
     *
     *          eat: function(foodType) {
     *              alert("I'm eating: " + foodType);
     *
     *              return this;
     *          }
     *     });
	 *
	 *     var aaron = new Person("Aaron");
	 *     aaron.eat("Sandwich"); // alert("I'm eating: Sandwich");
	 *
	 * Firebird.Class has a powerful set of extensible {@link Firebird.Class#registerPreprocessor pre-processors} which takes care of
	 * everything related to class creation, including but not limited to inheritance, mixins, configuration, statics, etc.
	 *
	 * # Inheritance:
	 *
	 *     Firebird.define('Developer', {
     *          extend: 'Person',
     *
     *          constructor: function(name, isGeek) {
     *              this.isGeek = isGeek;
     *
     *              // Apply a method from the parent class' prototype
     *              this.callParent([name]);
     *          },
     *
     *          code: function(language) {
     *              alert("I'm coding in: " + language);
     *
     *              this.eat("Bugs");
     *
     *              return this;
     *          }
     *     });
	 *
	 *     var jacky = new Developer("Jacky", true);
	 *     jacky.code("JavaScript"); // alert("I'm coding in: JavaScript");
	 *                               // alert("I'm eating: Bugs");
	 *
	 * See {@link Firebird.Base#callParent} for more details on calling superclass' methods
	 *
	 * # Mixins:
	 *
	 *     Firebird.define('CanPlayGuitar', {
     *          playGuitar: function() {
     *             alert("F#...G...D...A");
     *          }
     *     });
	 *
	 *     Firebird.define('CanComposeSongs', {
     *          composeSongs: function() { ... }
     *     });
	 *
	 *     Firebird.define('CanSing', {
     *          sing: function() {
     *              alert("I'm on the highway to hell...")
     *          }
     *     });
	 *
	 *     Firebird.define('Musician', {
     *          extend: 'Person',
     *
     *          mixins: {
     *              canPlayGuitar: 'CanPlayGuitar',
     *              canComposeSongs: 'CanComposeSongs',
     *              canSing: 'CanSing'
     *          }
     *     })
	 *
	 *     Firebird.define('CoolPerson', {
     *          extend: 'Person',
     *
     *          mixins: {
     *              canPlayGuitar: 'CanPlayGuitar',
     *              canSing: 'CanSing'
     *          },
     *
     *          sing: function() {
     *              alert("Ahem....");
     *
     *              this.mixins.canSing.sing.call(this);
     *
     *              alert("[Playing guitar at the same time...]");
     *
     *              this.playGuitar();
     *          }
     *     });
	 *
	 *     var me = new CoolPerson("Jacky");
	 *
	 *     me.sing(); // alert("Ahem...");
	 *                // alert("I'm on the highway to hell...");
	 *                // alert("[Playing guitar at the same time...]");
	 *                // alert("F#...G...D...A");
	 *
	 * # Config:
	 *
	 *     Firebird.define('SmartPhone', {
     *          config: {
     *              hasTouchScreen: false,
     *              operatingSystem: 'Other',
     *              price: 500
     *          },
     *
     *          isExpensive: false,
     *
     *          constructor: function(config) {
     *              this.initConfig(config);
     *          },
     *
     *          applyPrice: function(price) {
     *              this.isExpensive = (price > 500);
     *
     *              return price;
     *          },
     *
     *          applyOperatingSystem: function(operatingSystem) {
     *              if (!(/^(iOS|Android|BlackBerry)$/i).test(operatingSystem)) {
     *                  return 'Other';
     *              }
     *
     *              return operatingSystem;
     *          }
     *     });
	 *
	 *     var iPhone = new SmartPhone({
     *          hasTouchScreen: true,
     *          operatingSystem: 'iOS'
     *     });
	 *
	 *     iPhone.getPrice(); // 500;
	 *     iPhone.getOperatingSystem(); // 'iOS'
	 *     iPhone.getHasTouchScreen(); // true;
	 *     iPhone.hasTouchScreen(); // true
	 *
	 *     iPhone.isExpensive; // false;
	 *     iPhone.setPrice(600);
	 *     iPhone.getPrice(); // 600
	 *     iPhone.isExpensive; // true;
	 *
	 *     iPhone.setOperatingSystem('AlienOS');
	 *     iPhone.getOperatingSystem(); // 'Other'
	 *
	 * # Statics:
	 *
	 *     Firebird.define('Computer', {
     *          statics: {
     *              factory: function(brand) {
     *                 // 'this' in static methods refer to the class itself
     *                  return new this(brand);
     *              }
     *          },
     *
     *          constructor: function() { ... }
     *     });
	 *
	 *     var dellComputer = Computer.factory('Dell');
	 *
	 * Also see {@link Firebird.Base#statics} and {@link Firebird.Base#self} for more details on accessing
	 * static properties within class methods
	 *
	 * @singleton
	 */
	(function (Class, alias, arraySlice, arrayFrom, global) {

		// Creates a constructor that has nothing extra in its scope chain.
		// 创建一个构造器，这个构造器没有多余的东西在他的作用域链上
		function makeCtor() {
			function constructor() {
				// 这个是 Firebird OO Style 的构造器
				// 注意：如果你正在使用严格模式，Firebird OO 在IE下可能会出现caller无法访问的问题。
				// 注意：当Opera的web开发工具Dragonfly没有运行时，返回一个构造器会出现问题。
				try {
					return this.constructor.apply(this, arguments);
				} catch (e) {
					firebird.error(e);
					return null;
				}
			}

			return constructor;
		}

		var Manager = Firebird.ClassManager = {
			/**
			 * @property {Object} classes
			 * All classes which were defined through the ClassManager. Keys are the
			 * name of the classes and the values are references to the classes.
			 * @private
			 */
			classes: {},
			/**
			 * @private
			 */
			existCache: {},
			/**
			 * @private
			 */
			namespaceRewrites: [
				{
					from: 'Firebird.',
					to: Firebird
				}
			],
			/**
			 * @private
			 */
			maps: {
				alternateToName: {},
				aliasToName: {},
				nameToAliases: {},
				nameToAlternates: {}
			},
			/** @private */
			enableNamespaceParseCache: true,
			/** @private */
			namespaceParseCache: {},
			/** @private */
			instantiators: [],
			/**
			 * Checks if a class has already been created.
			 *
			 * @param {String} className
			 * @return {Boolean} exist
			 */
			isCreated: function (className) {
				var existCache = this.existCache,
					i, ln, part, root, parts;

				if (typeof className != 'string' || className.length < 1) {
					firebird.error(new Error("[Firebird.ClassManager] 无效的 classname, classname 必须是一个字符串，且不能为空！"));
				}

				if (this.classes[className] || existCache[className]) {
					return true;
				}

				root = global;
				parts = this.parseNamespace(className);

				for (i = 0, ln = parts.length; i < ln; i++) {
					part = parts[i];

					if (typeof part != 'string') {
						root = part;
					} else {
						if (!root || !root[part]) {
							return false;
						}

						root = root[part];
					}
				}

				existCache[className] = true;

				this.triggerCreated(className);

				return true;
			},
			/**
			 * @private
			 */
			createdListeners: [],
			/**
			 * @private
			 */
			nameCreatedListeners: {},
			/**
			 * @private
			 */
			triggerCreated: function (className) {
				var listeners = this.createdListeners,
					nameListeners = this.nameCreatedListeners,
					alternateNames = this.maps.nameToAlternates[className],
					names = [className],
					i, ln, j, subLn, listener, name;

				for (i = 0, ln = listeners.length; i < ln; i++) {
					listener = listeners[i];
					listener.fn.call(listener.scope, className);
				}

				if (alternateNames) {
					names.push.apply(names, alternateNames);
				}

				for (i = 0, ln = names.length; i < ln; i++) {
					name = names[i];
					listeners = nameListeners[name];

					if (listeners) {
						for (j = 0, subLn = listeners.length; j < subLn; j++) {
							listener = listeners[j];
							listener.fn.call(listener.scope, name);
						}
						delete nameListeners[name];
					}
				}
			},
			/**
			 * @private
			 */
			onCreated: function (fn, scope, className) {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(className, 'Firebird.ClassManager#onCreated', arguments);

				var listeners = this.createdListeners,
					nameListeners = this.nameCreatedListeners,
					listener = {
						fn: fn,
						scope: scope
					};

				if (className) {
					if (this.isCreated(className)) {
						fn.call(scope, className);
						return;
					}

					if (!nameListeners[className]) {
						nameListeners[className] = [];
					}

					nameListeners[className].push(listener);
				}
				else {
					listeners.push(listener);
				}
			},
			/**
			 * Supports namespace rewriting
			 * @private
			 */
			parseNamespace: function (namespace) {
				if (typeof namespace != 'string') {
					firebird.error(new Error("[Firebird.ClassManager] 无效的 namespace, 命名空间必须是一个字符串"));
				}

				var cache = this.namespaceParseCache,
					parts,
					rewrites,
					root,
					name,
					rewrite, from, to, i, ln;

				if (this.enableNamespaceParseCache) {
					if (cache.hasOwnProperty(namespace)) {
						return cache[namespace];
					}
				}

				parts = [];
				rewrites = this.namespaceRewrites;
				root = global;
				name = namespace;

				for (i = 0, ln = rewrites.length; i < ln; i++) {
					rewrite = rewrites[i];
					from = rewrite.from;
					to = rewrite.to;

					if (name === from || name.substring(0, from.length) === from) {
						name = name.substring(from.length);

						if (typeof to != 'string') {
							root = to;
						} else {
							parts = parts.concat(to.split('.'));
						}

						break;
					}
				}

				parts.push(root);

				parts = parts.concat(name.split('.'));

				if (this.enableNamespaceParseCache) {
					cache[namespace] = parts;
				}

				return parts;
			},
			/**
			 * Creates a namespace and assign the `value` to the created object
			 *
			 *     Firebird.ClassManager.setNamespace('MyCompany.pkg.Example', someObject);
			 *
			 *     alert(MyCompany.pkg.Example === someObject); // alerts true
			 *
			 * @param {String} name
			 * @param {Object} value
			 */
			setNamespace: function (name, value) {
				var root = global,
					parts = this.parseNamespace(name),
					ln = parts.length - 1,
					leaf = parts[ln],
					i, part;

				for (i = 0; i < ln; i++) {
					part = parts[i];

					if (typeof part != 'string') {
						root = part;
					} else {
						if (!root[part]) {
							root[part] = {};
						}

						root = root[part];
					}
				}

				root[leaf] = value;

				return root[leaf];
			},
			/**
			 * The new Firebird.ns, supports namespace rewriting
			 * @private
			 */
			createNamespaces: function () {
				var root = global,
					parts, part, i, j, ln, subLn;

				for (i = 0, ln = arguments.length; i < ln; i++) {
					parts = this.parseNamespace(arguments[i]);

					for (j = 0, subLn = parts.length; j < subLn; j++) {
						part = parts[j];

						if (typeof part != 'string') {
							root = part;
						} else {
							if (!root[part]) {
								root[part] = {};
							}

							root = root[part];
						}
					}
				}

				return root;
			},
			/**
			 * Sets a name reference to a class.
			 *
			 * @param {String} name
			 * @param {Object} value
			 * @return {Firebird.ClassManager} this
			 */
			set: function (name, value) {
				var me = this,
					maps = me.maps,
					nameToAlternates = maps.nameToAlternates,
					targetName = me.getName(value),
					alternates;

				me.classes[name] = me.setNamespace(name, value);

				if (targetName && targetName !== name) {
					maps.alternateToName[name] = targetName;
					alternates = nameToAlternates[targetName] || (nameToAlternates[targetName] = []);
					alternates.push(name);
				}

				return this;
			},
			/**
			 * Retrieve a class by its name.
			 *
			 * @param {String} name
			 * @return {Firebird.Class} class
			 */
			get: function (name) {
				var classes = this.classes,
					root,
					parts,
					part, i, ln;

				if (classes[name]) {
					return classes[name];
				}

				root = global;
				parts = this.parseNamespace(name);

				for (i = 0, ln = parts.length; i < ln; i++) {
					part = parts[i];

					if (typeof part != 'string') {
						root = part;
					} else {
						if (!root || !root[part]) {
							return null;
						}

						root = root[part];
					}
				}

				return root;
			},
			/**
			 * Register the alias for a class.
			 *
			 * @param {Firebird.Class/String} cls a reference to a class or a className
			 * @param {String} alias Alias to use when referring to this class
			 */
			setAlias: function (cls, alias) {
				var aliasToNameMap = this.maps.aliasToName,
					nameToAliasesMap = this.maps.nameToAliases,
					className;

				if (typeof cls == 'string') {
					className = cls;
				} else {
					className = this.getName(cls);
				}

				if (alias && aliasToNameMap[alias] !== className) {
					firebird.info("[Firebird.ClassManager] 重写现有的别名: '" + alias + "' " +
						"of: '" + aliasToNameMap[alias] + "' with: '" + className + "'. Be sure it's intentional.");
//                    if (aliasToNameMap[alias] && Firebird.isDefined(global.console)) {
//                        global.console.log("[Firebird.ClassManager] Overriding existing alias: '" + alias + "' " +
//                            "of: '" + aliasToNameMap[alias] + "' with: '" + className + "'. Be sure it's intentional.");
//                    }

					aliasToNameMap[alias] = className;
				}

				if (!nameToAliasesMap[className]) {
					nameToAliasesMap[className] = [];
				}

				if (alias) {
					Firebird.Array.include(nameToAliasesMap[className], alias);
				}

				return this;
			},
			/**
			 * 批量添加类名至别名映射表
			 * Adds a batch of class name to alias mappings
			 * @param {Object} aliases The set of mappings of the form
			 * className : [values...]
			 */
			addNameAliasMappings: function (aliases) {
				var aliasToNameMap = this.maps.aliasToName,
					nameToAliasesMap = this.maps.nameToAliases,
					className, aliasList, alias, i;

				for (className in aliases) {
					aliasList = nameToAliasesMap[className] ||
						(nameToAliasesMap[className] = []);

					for (i = 0; i < aliases[className].length; i++) {
						alias = aliases[className][i];
						if (!aliasToNameMap[alias]) {
							aliasToNameMap[alias] = className;
							aliasList.push(alias);
						}
					}

				}
				return this;
			},
			/**
			 *
			 * @param {Object} alternates The set of mappings of the form
			 * className : [values...]
			 */
			addNameAlternateMappings: function (alternates) {
				var alternateToName = this.maps.alternateToName,
					nameToAlternates = this.maps.nameToAlternates,
					className, aliasList, alternate, i;

				for (className in alternates) {
					aliasList = nameToAlternates[className] ||
						(nameToAlternates[className] = []);

					for (i = 0; i < alternates[className].length; i++) {
						alternate = alternates[className][i];
						if (!alternateToName[alternate]) {
							alternateToName[alternate] = className;
							aliasList.push(alternate);
						}
					}

				}
				return this;
			},
			/**
			 * Get a reference to the class by its alias.
			 *
			 * @param {String} alias
			 * @return {Firebird.Class} class
			 */
			getByAlias: function (alias) {
				return this.get(this.getNameByAlias(alias));
			},
			/**
			 * Get the name of a class by its alias.
			 *
			 * @param {String} alias
			 * @return {String} className
			 */
			getNameByAlias: function (alias) {
				return this.maps.aliasToName[alias] || '';
			},
			/**
			 * Get the name of a class by its alternate name.
			 *
			 * @param {String} alternate
			 * @return {String} className
			 */
			getNameByAlternate: function (alternate) {
				return this.maps.alternateToName[alternate] || '';
			},
			/**
			 * Get the aliases of a class by the class name
			 *
			 * @param {String} name
			 * @return {Array} aliases
			 */
			getAliasesByName: function (name) {
				return this.maps.nameToAliases[name] || [];
			},
			/**
			 * Get the name of the class by its reference or its instance;
			 *
			 * {@link Firebird.ClassManager#getName} is usually invoked by the shorthand {@link Firebird#getClassName}.
			 *
			 *     Firebird.getName(Firebird.Action); // returns "Firebird.Action"
			 *
			 * @param {Firebird.Class/Object} object
			 * @return {String} className
			 */
			getName: function (object) {
				return object && object.$className || '';
			},
			/**
			 * 获取类的提供者，如果不是由Firebird.define定义的类，则返回null
			 * Get the class of the provided object; returns null if it's not an instance
			 * of any class created with Firebird.define.
			 *
			 * {@link Firebird.ClassManager#getClass} is usually invoked by the shorthand {@link Firebird#getClass}.
			 *
			 *     var component = new Firebird.Component();
			 *
			 *     Firebird.getClass(component); // returns Firebird.Component
			 *
			 * @param {Object} object
			 * @return {Firebird.Class} class
			 */
			getClass: function (object) {
				return object && object.self || null;
			},
			/**
			 * Defines a class.
			 * @deprecated 4.1.0 Use {@link Firebird#define} instead, as that also supports creating overrides.
			 */
			create: function (className, data, createdFn) {
				if (className != null && typeof className != 'string') {
					firebird.error(new Error("[Firebird.define] 指定了无效的类名 '" + className + "', 请提供一个不为空的字符串"));
				}

				var ctor = makeCtor();
				if (typeof data == 'function') {
					data = data(ctor);
				}

				if (className) {
					ctor.displayName = className;
				}

				data.$className = className;

				return new Class(ctor, data, function () {
					var postprocessorStack = data.postprocessors || Manager.defaultPostprocessors,
						registeredPostprocessors = Manager.postprocessors,
						postprocessors = [],
						postprocessor, i, ln, j, subLn, postprocessorProperties, postprocessorProperty;

					delete data.postprocessors;

					for (i = 0, ln = postprocessorStack.length; i < ln; i++) {
						postprocessor = postprocessorStack[i];

						if (typeof postprocessor == 'string') {
							postprocessor = registeredPostprocessors[postprocessor];
							postprocessorProperties = postprocessor.properties;

							if (postprocessorProperties === true) {
								postprocessors.push(postprocessor.fn);
							}
							else if (postprocessorProperties) {
								for (j = 0, subLn = postprocessorProperties.length; j < subLn; j++) {
									postprocessorProperty = postprocessorProperties[j];

									if (data.hasOwnProperty(postprocessorProperty)) {
										postprocessors.push(postprocessor.fn);
										break;
									}
								}
							}
						}
						else {
							postprocessors.push(postprocessor);
						}
					}

					data.postprocessors = postprocessors;
					data.createdFn = createdFn;
					Manager.processCreate(className, this, data);
				});
			},
			processCreate: function (className, cls, clsData) {
				var me = this,
					postprocessor = clsData.postprocessors.shift(),
					createdFn = clsData.createdFn;

				if (!postprocessor) {
					Firebird.classSystemMonitor && Firebird.classSystemMonitor(className, 'Firebird.ClassManager#classCreated', arguments);

					if (className) {
						me.set(className, cls);
					}

					if (createdFn) {
						createdFn.call(cls, cls);
					}

					if (className) {
						me.triggerCreated(className);
					}
					return;
				}

				if (postprocessor.call(me, className, cls, clsData, me.processCreate) !== false) {
					me.processCreate(className, cls, clsData);
				}
			},
			createOverride: function (className, data, createdFn) {
				var me = this,
					overriddenClassName = data.override,
					requires = data.requires,
					uses = data.uses,
					classReady = function () {
						var cls, temp;

						if (requires) {
							temp = requires;
							requires = null; // do the real thing next time (which may be now)

							// Since the override is going to be used (its target class is now
							// created), we need to fetch the required classes for the override
							// and call us back once they are loaded:
							Firebird.Loader.require(temp, classReady);
						} else {
							// The target class and the required classes for this override are
							// ready, so we can apply the override now:
							cls = me.get(overriddenClassName);

							// We don't want to apply these:
							delete data.override;
							delete data.requires;
							delete data.uses;

							Firebird.override(cls, data);

							// This pushes the overridding file itself into Firebird.Loader.history
							// Hence if the target class never exists, the overriding file will
							// never be included in the build.
							me.triggerCreated(className);

							if (uses) {
								Firebird.Loader.addUsedClasses(uses); // get these classes too!
							}

							if (createdFn) {
								createdFn.call(cls); // last but not least!
							}
						}
					};

				me.existCache[className] = true;

				// Override the target class right after it's created
				me.onCreated(classReady, me, overriddenClassName);

				return me;
			},
			/**
			 * Instantiate a class by its alias.
			 *
			 * {@link Firebird.ClassManager#instantiateByAlias} is usually invoked by the shorthand {@link Firebird#createByAlias}.
			 *
			 * If {@link Firebird.Loader} is {@link Firebird.Loader#setConfig enabled} and the class has not been defined yet, it will
			 * attempt to load the class via synchronous loading.
			 *
			 *     var window = Firebird.createByAlias('widget.window', { width: 600, height: 800, ... });
			 *
			 * @param {String} alias
			 * @param {Object...} args Additional arguments after the alias will be passed to the
			 * class constructor.
			 * @return {Object} instance
			 */
			instantiateByAlias: function () {
				var alias = arguments[0],
					args = arraySlice.call(arguments),
					className = this.getNameByAlias(alias);

				if (!className) {
					className = this.maps.aliasToName[alias];

					if (!className) {
						firebird.error(new Error("[Firebird.createByAlias] 不能通过无法识别的别名创建一个实例: " + alias));
					}

					if (global.console) {
						global.console.warn("[Firebird.Loader] 同步加载 '" + className + "'; 可以考虑添加这句代码" +
							"Firebird.require('" + alias + "') 在 Firebird.onReady 前");
					}

					Firebird.syncRequire(className);
				}

				args[0] = className;

				return this.instantiate.apply(this, args);
			},
			/**
			 * @private
			 */
			instantiate: function () {
				var name = arguments[0],
					nameType = typeof name,
					args = arraySlice.call(arguments, 1),
					alias = name,
					possibleName, cls;

				if (nameType != 'function') {
					if (nameType != 'string' && args.length === 0) {
						args = [name];
						name = name.xclass;
					}

					if (typeof name != 'string' || name.length < 1) {
						firebird.error(new Error("[Firebird.create] 指定了无效的类名或别名 '" + name + "', 请提供一个不为空的字符串"));
					}

					cls = this.get(name);
				}
				else {
					cls = name;
				}

				// No record of this class name, it's possibly an alias, so look it up
				if (!cls) {
					possibleName = this.getNameByAlias(name);

					if (possibleName) {
						name = possibleName;

						cls = this.get(name);
					}
				}

				// Still no record of this class name, it's possibly an alternate name, so look it up
				if (!cls) {
					possibleName = this.getNameByAlternate(name);

					if (possibleName) {
						name = possibleName;

						cls = this.get(name);
					}
				}

				// Still not existing at this point, try to load it via synchronous mode as the last resort
				if (!cls) {
					if (global.console) {
						global.console.warn("[Firebird.Loader] 同步加载 '" + name + "'; 可以考虑加这句代码 " +
							"Firebird.require('" + ((possibleName) ? alias : name) + "') 在 Firebird.onReady 前");
					}

					Firebird.syncRequire(name);

					cls = this.get(name);
				}

				var flg = false;
				if (!cls) {
					flg = true;
					firebird.error(new Error("[Firebird.create] 无法通过不能识别的类名或别名创建实例: " + alias));
				}

				if (typeof cls != 'function' && flg === false) {
					firebird.error(new Error("[Firebird.create] '" + name + "' 是一个单例，无法实例化。"));
				}

				return this.getInstantiator(args.length)(cls, args);
			},
			/**
			 * @private
			 * @param name
			 * @param args
			 */
			dynInstantiate: function (name, args) {
				args = arrayFrom(args, true);
				args.unshift(name);

				return this.instantiate.apply(this, args);
			},
			/**
			 * @private
			 * @param length
			 */
			getInstantiator: function (length) {
				var instantiators = this.instantiators,
					instantiator,
					i,
					args;

				instantiator = instantiators[length];

				if (!instantiator) {
					i = length;
					args = [];

					for (i = 0; i < length; i++) {
						args.push('a[' + i + ']');
					}

					instantiator = instantiators[length] = new Function('c', 'a', 'return new c(' + args.join(',') + ')');
					instantiator.displayName = "Firebird.ClassManager.instantiate" + length;
				}

				return instantiator;
			},
			/**
			 * @private
			 */
			postprocessors: {},
			/**
			 * @private
			 */
			defaultPostprocessors: [],
			/**
			 * Register a post-processor function.
			 *
			 * @private
			 * @param {String} name
			 * @param {Function} postprocessor
			 */
			registerPostprocessor: function (name, fn, properties, position, relativeTo) {
				if (!position) {
					position = 'last';
				}

				if (!properties) {
					properties = [name];
				}

				this.postprocessors[name] = {
					name: name,
					properties: properties || false,
					fn: fn
				};

				this.setDefaultPostprocessorPosition(name, position, relativeTo);

				return this;
			},
			/**
			 * Set the default post processors array stack which are applied to every class.
			 *
			 * @private
			 * @param {String/Array} postprocessors The name of a registered post processor or an array of registered names.
			 * @return {Firebird.ClassManager} this
			 */
			setDefaultPostprocessors: function (postprocessors) {
				this.defaultPostprocessors = arrayFrom(postprocessors);

				return this;
			},
			/**
			 * Insert this post-processor at a specific position in the stack, optionally relative to
			 * any existing post-processor
			 *
			 * @private
			 * @param {String} name The post-processor name. Note that it needs to be registered with
			 * {@link Firebird.ClassManager#registerPostprocessor} before this
			 * @param {String} offset The insertion position. Four possible values are:
			 * 'first', 'last', or: 'before', 'after' (relative to the name provided in the third argument)
			 * @param {String} relativeName
			 * @return {Firebird.ClassManager} this
			 */
			setDefaultPostprocessorPosition: function (name, offset, relativeName) {
				var defaultPostprocessors = this.defaultPostprocessors,
					index;

				if (typeof offset == 'string') {
					if (offset === 'first') {
						defaultPostprocessors.unshift(name);

						return this;
					}
					else if (offset === 'last') {
						defaultPostprocessors.push(name);

						return this;
					}

					offset = (offset === 'after') ? 1 : -1;
				}

				index = Firebird.Array.indexOf(defaultPostprocessors, relativeName);

				if (index !== -1) {
					Firebird.Array.splice(defaultPostprocessors, Math.max(0, index + offset), 0, name);
				}

				return this;
			},
			/**
			 * Converts a string expression to an array of matching class names. An expression can either refers to class aliases
			 * or class names. Expressions support wildcards:
			 *
			 *      // returns ['Firebird.window.Window']
			 *     var window = Firebird.ClassManager.getNamesByExpression('widget.window');
			 *
			 *     // returns ['widget.panel', 'widget.window', ...]
			 *     var allWidgets = Firebird.ClassManager.getNamesByExpression('widget.*');
			 *
			 *     // returns ['Firebird.data.Store', 'Firebird.data.ArrayProxy', ...]
			 *     var allData = Firebird.ClassManager.getNamesByExpression('Firebird.data.*');
			 *
			 * @param {String} expression
			 * @return {String[]} classNames
			 */
			getNamesByExpression: function (expression) {
				var nameToAliasesMap = this.maps.nameToAliases,
					names = [],
					name, alias, aliases, possibleName, regex, i, ln;

				if (typeof expression != 'string' || expression.length < 1) {
					firebird.error(new Error("[Firebird.ClassManager.getNamesByExpression] 无效的表达式 " + expression + " , 必须提供一个非空字符串"));
				}

				if (expression.indexOf('*') !== -1) {
					expression = expression.replace(/\*/g, '(.*?)');
					regex = new RegExp('^' + expression + '$');

					for (name in nameToAliasesMap) {
						if (nameToAliasesMap.hasOwnProperty(name)) {
							aliases = nameToAliasesMap[name];

							if (name.search(regex) !== -1) {
								names.push(name);
							}
							else {
								for (i = 0, ln = aliases.length; i < ln; i++) {
									alias = aliases[i];

									if (alias.search(regex) !== -1) {
										names.push(name);
										break;
									}
								}
							}
						}
					}

				} else {
					possibleName = this.getNameByAlias(expression);

					if (possibleName) {
						names.push(possibleName);
					} else {
						possibleName = this.getNameByAlternate(expression);

						if (possibleName) {
							names.push(possibleName);
						} else {
							names.push(expression);
						}
					}
				}

				return names;
			}
		};

		/**
		 * @cfg {String[]} alias
		 * @member Firebird.Class
		 * List of short aliases for class names.  Most useful for defining xtypes for widgets:
		 *
		 *     Firebird.define('MyApp.CoolPanel', {
         *         extend: 'Firebird.panel.Panel',
         *         alias: ['widget.coolpanel'],
         *         title: 'Yeah!'
         *     });
		 *
		 *     // Using Firebird.create
		 *     Firebird.create('widget.coolpanel');
		 *
		 *     // Using the shorthand for defining widgets by xtype
		 *     Firebird.widget('panel', {
         *         items: [
         *             {xtype: 'coolpanel', html: 'Foo'},
         *             {xtype: 'coolpanel', html: 'Bar'}
         *         ]
         *     });
		 *
		 * Besides "widget" for xtype there are alias namespaces like "feature" for ftype and "plugin" for ptype.
		 */
		Manager.registerPostprocessor('alias', function (name, cls, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(name, 'Firebird.ClassManager#aliasPostProcessor', arguments);

			var aliases = data.alias,
				i, ln;

			for (i = 0, ln = aliases.length; i < ln; i++) {
				alias = aliases[i];

				this.setAlias(cls, alias);
			}

		}, ['xtype', 'alias']);

		/**
		 * @cfg {Boolean} singleton
		 * @member Firebird.Class
		 * When set to true, the class will be instantiated as singleton.  例子:
		 *
		 *     Firebird.define('Logger', {
         *         singleton: true,
         *         log: function(msg) {
         *             console.log(msg);
         *         }
         *     });
		 *
		 *     Logger.log('Hello');
		 */
		Manager.registerPostprocessor('singleton', function (name, cls, data, fn) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(name, 'Firebird.ClassManager#singletonPostProcessor', arguments);

			if (data.singleton) {
				fn.call(this, name, new cls(), data);
			}
			else {
				return true;
			}
			return false;
		});

		/**
		 * 为此类定义备用名
		 * @cfg {String/String[]} alternateClassName
		 * @member Firebird.Class
		 *
		 * 例子:
		 *
		 *     Firebird.define('Developer', {
         *         alternateClassName: ['Coder', 'Hacker'],
         *         code: function(msg) {
         *             alert('Typing... ' + msg);
         *         }
         *     });
		 *
		 *     var joe = Firebird.create('Developer');
		 *     joe.code('stackoverflow');
		 *
		 *     var rms = Firebird.create('Hacker');
		 *     rms.code('hack hack');
		 */
		Manager.registerPostprocessor('alternateClassName', function (name, cls, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(name, 'Firebird.ClassManager#alternateClassNamePostprocessor', arguments);

			var alternates = data.alternateClassName,
				i, ln, alternate;

			if (!(alternates instanceof Array)) {
				alternates = [alternates];
			}

			for (i = 0, ln = alternates.length; i < ln; i++) {
				alternate = alternates[i];

				if (typeof alternate != 'string') {
					firebird.error(new Error("[Firebird.define] 无效的备用名: '" + alternate + "' 在此类中: '" + name + "'; 必须是一个有效的字符串"));
				}

				this.set(alternate, cls);
			}
		});

		Firebird.apply(Firebird, {
			/**
			 * Instantiate a class by either full name, alias or alternate name.
			 *
			 * If {@link Firebird.Loader} is {@link Firebird.Loader#setConfig enabled} and the class has
			 * not been defined yet, it will attempt to load the class via synchronous loading.
			 *
			 * 例子, all these three lines return the same result:
			 *
			 *      // alias
			 *      var window = Firebird.create('widget.window', {
             *          width: 600,
             *          height: 800,
             *          ...
             *      });
			 *
			 *      // alternate name
			 *      var window = Firebird.create('Firebird.Window', {
             *          width: 600,
             *          height: 800,
             *          ...
             *      });
			 *
			 *      // full class name
			 *      var window = Firebird.create('Firebird.window.Window', {
             *          width: 600,
             *          height: 800,
             *          ...
             *      });
			 *
			 *      // single object with xclass property:
			 *      var window = Firebird.create({
             *          xclass: 'Firebird.window.Window', // any valid value for 'name' (above)
             *          width: 600,
             *          height: 800,
             *          ...
             *      });
			 *
			 * @param {String} [name] The class name or alias. Can be specified as `xclass`
			 * property if only one object parameter is specified.
			 * @param {Object...} [args] Additional arguments after the name will be passed to
			 * the class' constructor.
			 * @return {Object} instance
			 * @member Firebird
			 * @method create
			 */
			create: alias(Manager, 'instantiate'),
			/**
			 * Convenient shorthand to create a widget by its xtype or a config object.
			 * 参见 {@link Firebird.ClassManager#instantiateByAlias}.
			 *
			 *      var button = Firebird.widget('button'); // Equivalent to Firebird.create('widget.button');
			 *
			 *      var panel = Firebird.widget('panel', { // Equivalent to Firebird.create('widget.panel')
             *          title: 'Panel'
             *      });
			 *
			 *      var grid = Firebird.widget({
             *          xtype: 'grid',
             *          ...
             *      });
			 *
			 * If a {@link Firebird.Component component} instance is passed, it is simply returned.
			 *
			 * @member Firebird
			 * @param {String} [name] The xtype of the widget to create.
			 * @param {Object} [config] The configuration object for the widget constructor.
			 * @return {Object} The widget instance
			 */
			widget: function (name, config) {
				// forms:
				//      1: (xtype)
				//      2: (xtype, config)
				//      3: (config)
				//      4: (xtype, component)
				//      5: (component)
				//
				var xtype = name,
					alias, className, T, load;

				if (typeof xtype != 'string') { // if (form 3 or 5)
					// first arg is config or component
					config = name; // arguments[0]
					xtype = config.xtype;
				} else {
					config = config || {};
				}

				if (config.isComponent) {
					return config;
				}

				alias = 'widget.' + xtype;
				className = Manager.getNameByAlias(alias);

				// this is needed to support demand loading of the class
				if (!className) {
					load = true;
				}

				T = Manager.get(className);
				if (load || !T) {
					return Manager.instantiateByAlias(alias, config);
				}
				return new T(config);
			},
			/**
			 * @inheritdoc Firebird.ClassManager#instantiateByAlias
			 * @member Firebird
			 * @method createByAlias
			 */
			createByAlias: alias(Manager, 'instantiateByAlias'),
			/**
			 * 定义或重写一个类. 你像这样可以定义一个简单类:
			 *
			 *      Firebird.define('My.awesome.Class', {
             *          someProperty: 'something',
             *
             *          someMethod: function(s) {
             *              alert(s + this.someProperty);
             *          }
             *
             *          ...
             *      });
			 *
			 *      var obj = new My.awesome.Class();
			 *
			 *      obj.someMethod('Say '); // alerts 'Say something'
			 *
			 * 要定义一个匿名类 , 可以把`className` 设为 `null` ,如:
			 *
			 *      Firebird.define(null, {
             *          constructor: function () {
             *              // ...
             *          }
             *      });
			 *
			 * In some cases, it is helpful to create a nested scope to contain some private
			 * properties. The best way to do this is to pass a function instead of an object
			 * as the second parameter. This function will be called to produce the class
			 * body:
			 *
			 *      Firebird.define('MyApp.foo.Bar', function () {
             *          var id = 0;
             *
             *          return {
             *              nextId: function () {
             *                  return ++id;
             *              }
             *          };
             *      });
			 *
			 * _Note_ that when using override, the above syntax will not override successfully, because
			 * the passed function would need to be executed first to determine whether or not the result
			 * is an override or defining a new object. As such, an alternative syntax that immediately
			 * invokes the function can be used:
			 *
			 *      Firebird.define('MyApp.override.BaseOverride', function () {
             *          var counter = 0;
             *
             *          return {
             *              override: 'Firebird.Component',
             *              logId: function () {
             *                  console.log(++counter, this.id);
             *              }
             *          };
             *      }());
			 *
			 *
			 * When using this form of `Firebird.define`, the function is passed a reference to its
			 * class. This can be used as an efficient way to access any static properties you
			 * may have:
			 *
			 *      Firebird.define('MyApp.foo.Bar', function (Bar) {
             *          return {
             *              statics: {
             *                  staticMethod: function () {
             *                      // ...
             *                  }
             *              },
             *
             *              method: function () {
             *                  return Bar.staticMethod();
             *              }
             *          };
             *      });
			 *
			 * To define an override, include the `override` property. The content of an
			 * override is aggregated with the specified class in order to extend or modify
			 * that class. This can be as simple as setting default property values or it can
			 * extend and/or replace methods. This can also extend the statics of the class.
			 *
			 * One use for an override is to break a large class into manageable pieces.
			 *
			 *      // File: /src/app/Panel.js
			 *
			 *      Firebird.define('My.app.Panel', {
             *          extend: 'Firebird.panel.Panel',
             *          requires: [
             *              'My.app.PanelPart2',
             *              'My.app.PanelPart3'
             *          ]
             *
             *          constructor: function (config) {
             *              this.callParent(arguments); // calls Firebird.panel.Panel's constructor
             *              //...
             *          },
             *
             *          statics: {
             *              method: function () {
             *                  return 'abc';
             *              }
             *          }
             *      });
			 *
			 *      // File: /src/app/PanelPart2.js
			 *      Firebird.define('My.app.PanelPart2', {
             *          override: 'My.app.Panel',
             *
             *          constructor: function (config) {
             *              this.callParent(arguments); // calls My.app.Panel's constructor
             *              //...
             *          }
             *      });
			 *
			 * Another use of overrides is to provide optional parts of classes that can be
			 * independently required. In this case, the class may even be unaware of the
			 * override altogether.
			 *
			 *      Firebird.define('My.ux.CoolTip', {
             *          override: 'Firebird.tip.ToolTip',
             *
             *          constructor: function (config) {
             *              this.callParent(arguments); // calls Firebird.tip.ToolTip's constructor
             *              //...
             *          }
             *      });
			 *
			 * The above override can now be required as normal.
			 *
			 *      Firebird.define('My.app.App', {
             *          requires: [
             *              'My.ux.CoolTip'
             *          ]
             *      });
			 *
			 * Overrides can also contain statics:
			 *
			 *      Firebird.define('My.app.BarMod', {
             *          override: 'Firebird.foo.Bar',
             *
             *          statics: {
             *              method: function (x) {
             *                  return this.callParent([x * 2]); // call Firebird.foo.Bar.method
             *              }
             *          }
             *      });
			 *
			 * IMPORTANT: An override is only included in a build if the class it overrides is
			 * required. Otherwise, the override, like the target class, is not included.
			 *
			 * @param {String} className The class name to create in string dot-namespaced format, for example:
			 * 'My.very.awesome.Class', 'FeedViewer.plugin.CoolPager'
			 * It is highly recommended to follow this simple convention:
			 *  - The root and the class name are 'CamelCased'
			 *  - Everything else is lower-cased
			 * Pass `null` to create an anonymous class.
			 * @param {Object} data The key - value pairs of properties to apply to this class. Property names can be of any valid
			 * strings, except those in the reserved listed below:
			 *  - `mixins`
			 *  - `statics`
			 *  - `config`
			 *  - `alias`
			 *  - `self`
			 *  - `singleton`
			 *  - `alternateClassName`
			 *  - `override`
			 *
			 * @param {Function} createdFn Optional callback to execute after the class is created, the execution scope of which
			 * (`this`) will be the newly created class itself.
			 * @return {Firebird.Base}
			 * @member Firebird
			 */
			define: function (className, data, createdFn) {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(className, 'ClassManager#define', arguments);

				if (data.override) {
					return Manager.createOverride.apply(Manager, arguments);
				}

				return Manager.create.apply(Manager, arguments);
			},
			/**
			 * Undefines a class defined using the #define method. Typically used
			 * for unit testing where setting up and tearing down a class multiple
			 * times is required.  例子:
			 *
			 *     // define a class
			 *     Firebird.define('Foo', {
             *        ...
             *     });
			 *
			 *     // run test
			 *
			 *     // undefine the class
			 *     Firebird.undefine('Foo');
			 * @param {String} className The class name to undefine in string dot-namespaced format.
			 * @private
			 */
			undefine: function (className) {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(className, 'Firebird.ClassManager#undefine', arguments);

				var classes = Manager.classes,
					maps = Manager.maps,
					aliasToName = maps.aliasToName,
					nameToAliases = maps.nameToAliases,
					alternateToName = maps.alternateToName,
					nameToAlternates = maps.nameToAlternates,
					aliases = nameToAliases[className],
					alternates = nameToAlternates[className],
					parts, partCount, namespace, i;

				delete Manager.namespaceParseCache[className];
				delete nameToAliases[className];
				delete nameToAlternates[className];
				delete classes[className];

				if (aliases) {
					for (i = aliases.length; i--;) {
						delete aliasToName[aliases[i]];
					}
				}

				if (alternates) {
					for (i = alternates.length; i--;) {
						delete alternateToName[alternates[i]];
					}
				}

				parts = Manager.parseNamespace(className);
				partCount = parts.length - 1;
				namespace = parts[0];

				for (i = 1; i < partCount; i++) {
					namespace = namespace[parts[i]];
					if (!namespace) {
						return;
					}
				}

				// Old IE blows up on attempt to delete window property
				try {
					delete namespace[parts[partCount]];
				}
				catch (e) {
					namespace[parts[partCount]] = undefined;
				}
			},
			/**
			 * @inheritdoc Firebird.ClassManager#getName
			 * @member Firebird
			 * @method getClassName
			 */
			getClassName: alias(Manager, 'getName'),
			/**
			 * Returns the displayName property or className or object. When all else fails, returns "Anonymous".
			 * @param {Object} object
			 * @return {String}
			 */
			getDisplayName: function (object) {
				if (object) {
					if (object.displayName) {
						return object.displayName;
					}

					if (object.$name && object.$class) {
						return Firebird.getClassName(object.$class) + '#' + object.$name;
					}

					if (object.$className) {
						return object.$className;
					}
				}

				return 'Anonymous';
			},
			/**
			 * @inheritdoc Firebird.ClassManager#getClass
			 * @member Firebird
			 * @method getClass
			 */
			getClass: alias(Manager, 'getClass'),
			/**
			 * Creates namespaces to be used for scoping variables and classes so that they are not global.
			 * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
			 *
			 *     Firebird.namespace('Company', 'Company.data');
			 *
			 *     // equivalent and preferable to the above syntax
			 *     Firebird.ns('Company.data');
			 *
			 *     Company.Widget = function() { ... };
			 *
			 *     Company.data.CustomStore = function(config) { ... };
			 *
			 * @param {String...} namespaces
			 * @return {Object} The namespace object.
			 * (If multiple arguments are passed, this will be the last namespace created)
			 * @member Firebird
			 * @method namespace
			 */
			namespace: alias(Manager, 'createNamespaces')
		});

		/**
		 * Old name for {@link Firebird#widget}.
		 * @deprecated 4.0.0 Use {@link Firebird#widget} instead.
		 * @method createWidget
		 * @member Firebird
		 */
		Firebird.createWidget = Firebird.widget;

		/**
		 * Convenient alias for {@link Firebird#namespace Firebird.namespace}.
		 * @inheritdoc Firebird#namespace
		 * @member Firebird
		 * @method ns
		 */
		Firebird.ns = Firebird.namespace;

		Class.registerPreprocessor('className', function (cls, data) {
			if (data.$className) {
				cls.$className = data.$className;
				cls.displayName = cls.$className;
			}

			Firebird.classSystemMonitor && Firebird.classSystemMonitor(cls, 'Firebird.ClassManager#classNamePreprocessor', arguments);
		}, true, 'first');

		Class.registerPreprocessor('alias', function (cls, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(cls, 'Firebird.ClassManager#aliasPreprocessor', arguments);

			var prototype = cls.prototype,
				xtypes = arrayFrom(data.xtype),
				aliases = arrayFrom(data.alias),
				widgetPrefix = 'widget.',
				widgetPrefixLength = widgetPrefix.length,
				xtypesChain = Array.prototype.slice.call(prototype.xtypesChain || []),
				xtypesMap = Firebird.merge({}, prototype.xtypesMap || {}),
				i, ln, alias, xtype;

			for (i = 0, ln = aliases.length; i < ln; i++) {
				alias = aliases[i];

				if (typeof alias != 'string' || alias.length < 1) {
					firebird.error(new Error("[Firebird.define] 无效的别名: '" + alias + "' 在此类中: '" + name + "'; 必须是一个有效的字符串"));
				}

				if (alias.substring(0, widgetPrefixLength) === widgetPrefix) {
					xtype = alias.substring(widgetPrefixLength);
					Firebird.Array.include(xtypes, xtype);
				}
			}

			cls.xtype = data.xtype = xtypes[0];
			data.xtypes = xtypes;

			for (i = 0, ln = xtypes.length; i < ln; i++) {
				xtype = xtypes[i];

				if (!xtypesMap[xtype]) {
					xtypesMap[xtype] = true;
					xtypesChain.push(xtype);
				}
			}

			data.xtypesChain = xtypesChain;
			data.xtypesMap = xtypesMap;

			Firebird.Function.interceptAfter(data, 'onClassCreated', function () {
				Firebird.classSystemMonitor && Firebird.classSystemMonitor(cls, 'Firebird.ClassManager#aliasPreprocessor#afterClassCreated', arguments);

				var mixins = prototype.mixins,
					key, mixin;

				for (key in mixins) {
					if (mixins.hasOwnProperty(key)) {
						mixin = mixins[key];

						xtypes = mixin.xtypes;

						if (xtypes) {
							for (i = 0, ln = xtypes.length; i < ln; i++) {
								xtype = xtypes[i];

								if (!xtypesMap[xtype]) {
									xtypesMap[xtype] = true;
									xtypesChain.push(xtype);
								}
							}
						}
					}
				}
			});

			for (i = 0, ln = xtypes.length; i < ln; i++) {
				xtype = xtypes[i];

				if (typeof xtype != 'string' || xtype.length < 1) {
					firebird.error(new Error("[Firebird.define] 无效的 xtype: '" + xtype + "' 在此类中: '" + name + "'; 必须是一个有效的非空字符串"));
				}

				Firebird.Array.include(aliases, widgetPrefix + xtype);
			}

			data.alias = aliases;

		}, ['xtype', 'alias']);

	}(Firebird.Class, Firebird.Function.alias, Array.prototype.slice, Firebird.Array.from, Firebird.global));

// simple mechanism for automated means of injecting large amounts of dependency info
// at the appropriate time in the load cycle
	if (Firebird._alternatesMetadata) {
		Firebird.ClassManager.addNameAlternateMappings(Firebird._alternatesMetadata);
		Firebird._alternatesMetadata = null;
	}

	if (Firebird._aliasMetadata) {
		Firebird.ClassManager.addNameAliasMappings(Firebird._aliasMetadata);
		Firebird._aliasMetadata = null;
	}

// @tag foundation,core
// @require ClassManager.js
// @define Firebird.Loader

	/**
	 * @author Jacky Nguyen <jacky@sencha.com>
	 * @docauthor Jacky Nguyen <jacky@sencha.com>
	 * @class Firebird.Loader
	 *
	 * Firebird.Loader is the heart of the new dynamic dependency loading capability in Firebird JS 4+. It is most commonly used
	 * via the {@link Firebird#require} shorthand. Firebird.Loader supports both asynchronous and synchronous loading
	 * approaches, and leverage their advantages for the best development flow. We'll discuss about the pros and cons of each approach:
	 *
	 * # Asynchronous Loading #
	 *
	 * - Advantages:
	 *     + Cross-domain
	 *     + No web server needed: you can run the application via the file system protocol (i.e: `file://path/to/your/index
	 *  .html`)
	 *     + Best possible debugging experience: error messages come with the exact file name and line number
	 *
	 * - Disadvantages:
	 *     + Dependencies need to be specified before-hand
	 *
	 * ### Method 1: Explicitly include what you need: ###
	 *
	 *     // Syntax
	 *     Firebird.require({String/Array} expressions);
	 *
	 *     // Example: Single alias
	 *     Firebird.require('widget.window');
	 *
	 *     // Example: Single class name
	 *     Firebird.require('Firebird.window.Window');
	 *
	 *     // Example: Multiple aliases / class names mix
	 *     Firebird.require(['widget.window', 'layout.border', 'Firebird.data.Connection']);
	 *
	 *     // Wildcards
	 *     Firebird.require(['widget.*', 'layout.*', 'Firebird.data.*']);
	 *
	 * ### Method 2: Explicitly exclude what you don't need: ###
	 *
	 *     // Syntax: Note that it must be in this chaining format.
	 *     Firebird.exclude({String/Array} expressions)
	 *        .require({String/Array} expressions);
	 *
	 *     // Include everything except Firebird.data.*
	 *     Firebird.exclude('Firebird.data.*').require('*');
	 *
	 *     // Include all widgets except widget.checkbox*,
	 *     // which will match widget.checkbox, widget.checkboxfield, widget.checkboxgroup, etc.
	 *     Firebird.exclude('widget.checkbox*').require('widget.*');
	 *
	 * # Synchronous Loading on Demand #
	 *
	 * - Advantages:
	 *     + There's no need to specify dependencies before-hand, which is always the convenience of including ext-all.js
	 *  before
	 *
	 * - Disadvantages:
	 *     + Not as good debugging experience since file name won't be shown (except in Firebug at the moment)
	 *     + Must be from the same domain due to XHR restriction
	 *     + Need a web server, same reason as above
	 *
	 * There's one simple rule to follow: Instantiate everything with Firebird.create instead of the `new` keyword
	 *
	 *     Firebird.create('widget.window', { ... }); // Instead of new Firebird.window.Window({...});
	 *
	 *     Firebird.create('Firebird.window.Window', {}); // Same as above, using full class name instead of alias
	 *
	 *     Firebird.widget('window', {}); // Same as above, all you need is the traditional `xtype`
	 *
	 * Behind the scene, {@link Firebird.ClassManager} will automatically check whether the given class name / alias has already
	 *  existed on the page. If it's not, Firebird.Loader will immediately switch itself to synchronous mode and automatic load the given
	 *  class and all its dependencies.
	 *
	 * # Hybrid Loading - The Best of Both Worlds #
	 *
	 * It has all the advantages combined from asynchronous and synchronous loading. The development flow is simple:
	 *
	 * ### Step 1: Start writing your application using synchronous approach.
	 *
	 * Firebird.Loader will automatically fetch all dependencies on demand as they're needed during run-time. 例子:
	 *
	 *     Firebird.onReady(function(){
     *         var window = Firebird.widget('window', {
     *             width: 500,
     *             height: 300,
     *             layout: {
     *                 type: 'border',
     *                 padding: 5
     *             },
     *             title: 'Hello Dialog',
     *             items: [{
     *                 title: 'Navigation',
     *                 collapsible: true,
     *                 region: 'west',
     *                 width: 200,
     *                 html: 'Hello',
     *                 split: true
     *             }, {
     *                 title: 'TabPanel',
     *                 region: 'center'
     *             }]
     *         });
     *
     *         window.show();
     *     })
	 *
	 * ### Step 2: Along the way, when you need better debugging ability, watch the console for warnings like these: ###
	 *
	 *     [Firebird.Loader] Synchronously loading 'Firebird.window.Window'; consider adding Firebird.require('Firebird.window.Window') before your application's code
	 *     ClassManager.js:432
	 *     [Firebird.Loader] Synchronously loading 'Firebird.layout.container.Border'; consider adding Firebird.require('Firebird.layout.container.Border') before your application's code
	 *
	 * Simply copy and paste the suggested code above `Firebird.onReady`, i.e:
	 *
	 *     Firebird.require('Firebird.window.Window');
	 *     Firebird.require('Firebird.layout.container.Border');
	 *
	 *     Firebird.onReady(...);
	 *
	 * Everything should now load via asynchronous mode.
	 *
	 * # Deployment #
	 *
	 * It's important to note that dynamic loading should only be used during development on your local machines.
	 * During production, all dependencies should be combined into one single JavaScript file. Firebird.Loader makes
	 * the whole process of transitioning from / to between development / maintenance and production as easy as
	 * possible. Internally {@link Firebird.Loader#history Firebird.Loader.history} maintains the list of all dependencies your application
	 * needs in the exact loading sequence. It's as simple as concatenating all files in this array into one,
	 * then include it on top of your application.
	 *
	 * This process will be automated with Sencha Command, to be released and documented towards Firebird JS 4 Final.
	 *
	 * @singleton
	 */

	Firebird.Loader = new function () {
		var Loader = this,
			Manager = Firebird.ClassManager,
			Class = Firebird.Class,
			flexSetter = Firebird.Function.flexSetter,
			alias = Firebird.Function.alias,
			pass = Firebird.Function.pass,
			defer = Firebird.Function.defer,
			arrayErase = Firebird.Array.erase,
			dependencyProperties = ['extend', 'mixins', 'requires'],
			isInHistory = {},
			history = [],
			slashDotSlashRe = /\/\.\//g,
			dotRe = /\./g,
			setPathCount = 0;

		Firebird.apply(Loader, {
			/**
			 * @private
			 */
			isInHistory: isInHistory,
			/**
			 * An array of class names to keep track of the dependency loading order.
			 * This is not guaranteed to be the same everytime due to the asynchronous
			 * nature of the Loader.
			 *
			 * @property {Array} history
			 */
			history: history,
			/**
			 * Configuration
			 * @private
			 */
			config: {
				/**
				 * @cfg {Boolean} enabled
				 * Whether or not to enable the dynamic dependency loading feature.
				 */
				enabled: false,
				/**
				 * @cfg {Boolean} scriptChainDelay
				 * millisecond delay between asynchronous script injection (prevents stack overflow on some user agents)
				 * 'false' disables delay but potentially increases stack load.
				 */
				scriptChainDelay: false,
				/**
				 * @cfg {Boolean} disableCaching
				 * Appends current timestamp to script files to prevent caching.
				 */
				disableCaching: true,
				/**
				 * @cfg {String} disableCachingParam
				 * The get parameter name for the cache buster's timestamp.
				 */
				disableCachingParam: '_fb',
				/**
				 * @cfg {Boolean} garbageCollect
				 * True to prepare an asynchronous script tag for garbage collection (effective only
				 * if {@link #preserveScripts preserveScripts} is false)
				 */
				garbageCollect: false,
				/**
				 * @cfg {Object} paths
				 * The mapping from namespaces to file paths
				 *
				 *     {
                 *         'Firebird': '.', // This is set by default, Firebird.layout.container.Container will be
                 *                     // loaded from ./layout/Container.js
                 *
                 *         'My': './src/my_own_folder' // My.layout.Container will be loaded from
                 *                                     // ./src/my_own_folder/layout/Container.js
                 *     }
				 *
				 * Note that all relative paths are relative to the current HTML document.
				 * If not being specified, for example, <code>Other.awesome.Class</code>
				 * will simply be loaded from <code>./Other/awesome/Class.js</code>
				 */
				paths: {
					"Firebird": fb.data.base + 'resource/fb-boot/js/Class.js',
					"Firebird.ui.Dialog": fb.data.base + 'resource/fb-core/js/Dialog.js'
				},
				/**
				 * @cfg {Boolean} preserveScripts
				 * False to remove and optionally {@link #garbageCollect garbage-collect} asynchronously loaded scripts,
				 * True to retain script element for browser debugger compatibility and improved load performance.
				 */
				preserveScripts: true,
				/**
				 * @cfg {String} scriptCharset
				 * Optional charset to specify encoding of dynamic script content.
				 */
				scriptCharset: undefined
			},
			/**
			 * Set the configuration for the loader. This should be called right after ext-(debug).js
			 * is included in the page, and before Firebird.onReady. i.e:
			 *
			 *     <script type="text/javascript" src="ext-core-debug.js"></script>
			 *     <script type="text/javascript">
			 *         Firebird.Loader.setConfig({
             *           enabled: true,
             *           paths: {
             *               'My': 'my_own_path'
             *           }
             *         });
			 *     </script>
			 *     <script type="text/javascript">
			 *         Firebird.require(...);
			 *
			 *         Firebird.onReady(function() {
             *           // application code here
             *         });
			 *     </script>
			 *
			 * Refer to config options of {@link Firebird.Loader} for the list of possible properties
			 *
			 * @param {Object} config The config object to override the default values
			 * @return {Firebird.Loader} this
			 */
			setConfig: function (name, value) {
				if (Firebird.isObject(name) && arguments.length === 1) {
					Firebird.merge(Loader.config, name);

					if ('paths' in name) {
						Firebird.app.collectNamespaces(name.paths);
					}
				}
				else {
					Loader.config[name] = (Firebird.isObject(value)) ? Firebird.merge(Loader.config[name], value) : value;

					if (name === 'paths') {
						Firebird.app.collectNamespaces(value);
					}
				}

				return Loader;
			},
			/**
			 * Get the config value corresponding to the specified name. If no name is given, will return the config object
			 * @param {String} name The config property name
			 * @return {Object}
			 */
			getConfig: function (name) {
				if (name) {
					return Loader.config[name];
				}

				return Loader.config;
			},
			/**
			 * Sets the path of a namespace.
			 * For Example:
			 *
			 *     Firebird.Loader.setPath('Firebird', '.');
			 *
			 * @param {String/Object} name See {@link Firebird.Function#flexSetter flexSetter}
			 * @param {String} [path] See {@link Firebird.Function#flexSetter flexSetter}
			 * @return {Firebird.Loader} this
			 * @method
			 */
			setPath: flexSetter(function (name, path) {
				Loader.config.paths[name] = path;
				Firebird.app.namespaces[name] = true;
				setPathCount++;

				return Loader;
			}),
			/**
			 * Sets a batch of path entries
			 *
			 * @param {Object } paths a set of className: path mappings
			 * @return {Firebird.Loader} this
			 */
			addClassPathMappings: function (paths) {
				var name;

				if (setPathCount == 0) {
					Loader.config.paths = paths;
				} else {
					for (name in paths) {
						Loader.config.paths[name] = paths[name];
					}
				}
				setPathCount++;
				return Loader;
			},
			/**
			 * Translates a className to a file path by adding the
			 * the proper prefix and converting the .'s to /'s. 例子:
			 *
			 *     Firebird.Loader.setPath('My', '/path/to/My');
			 *
			 *     alert(Firebird.Loader.getPath('My.awesome.Class')); // alerts '/path/to/My/awesome/Class.js'
			 *
			 * Note that the deeper namespace levels, if explicitly set, are always resolved first. 例子:
			 *
			 *     Firebird.Loader.setPath({
             *         'My': '/path/to/lib',
             *         'My.awesome': '/other/path/for/awesome/stuff',
             *         'My.awesome.more': '/more/awesome/path'
             *     });
			 *
			 *     alert(Firebird.Loader.getPath('My.awesome.Class')); // alerts '/other/path/for/awesome/stuff/Class.js'
			 *
			 *     alert(Firebird.Loader.getPath('My.awesome.more.Class')); // alerts '/more/awesome/path/Class.js'
			 *
			 *     alert(Firebird.Loader.getPath('My.cool.Class')); // alerts '/path/to/lib/cool/Class.js'
			 *
			 *     alert(Firebird.Loader.getPath('Unknown.strange.Stuff')); // alerts 'Unknown/strange/Stuff.js'
			 *
			 * @param {String} className
			 * @return {String} path
			 */
			getPath: function (className) {
				return fb.resolve(className);
			},
			/**
			 * @private
			 * @param {String} className
			 */
			getPrefix: function (className) {
				var paths = Loader.config.paths,
					prefix, deepestPrefix = '';

				if (paths.hasOwnProperty(className)) {
					return className;
				}

				for (prefix in paths) {
					if (paths.hasOwnProperty(prefix) && prefix + '.' === className.substring(0, prefix.length + 1)) {
						if (prefix.length > deepestPrefix.length) {
							deepestPrefix = prefix;
						}
					}
				}

				return deepestPrefix;
			},
			/**
			 * @private
			 * @param {String} className
			 */
			isAClassNameWithAKnownPrefix: function (className) {
				var prefix = Loader.getPrefix(className);

				// we can only say it's really a class if className is not equal to any known namespace
				return prefix !== '' && prefix !== className;
			},
			/**
			 * Loads all classes by the given names and all their direct dependencies; optionally executes
			 * the given callback function when finishes, within the optional scope.
			 *
			 * {@link Firebird#require} is alias for {@link Firebird.Loader#require}.
			 *
			 * @param {String/Array} expressions Can either be a string or an array of string
			 * @param {Function} fn (Optional) The callback function
			 * @param {Object} scope (Optional) The execution scope (`this`) of the callback function
			 * @param {String/Array} excludes (Optional) Classes to be excluded, useful when being used with expressions
			 */
			require: function (expressions, fn, scope, excludes) {
				if (fn) {
					fn.call(scope);
				}
			},
			/**
			 * Synchronously loads all classes by the given names and all their direct dependencies; optionally
			 * executes the given callback function when finishes, within the optional scope.
			 *
			 * {@link Firebird#syncRequire} is alias for {@link Firebird.Loader#syncRequire}.
			 *
			 * @param {String/Array} expressions Can either be a string or an array of string
			 * @param {Function} fn (Optional) The callback function
			 * @param {Object} scope (Optional) The execution scope (`this`) of the callback function
			 * @param {String/Array} excludes (Optional) Classes to be excluded, useful when being used with expressions
			 */
			syncRequire: function () {
			},
			/**
			 * Explicitly exclude files from being loaded. Useful when used in conjunction with a broad include expression.
			 * Can be chained with more `require` and `exclude` methods, eg:
			 *
			 *     Firebird.exclude('Firebird.data.*').require('*');
			 *
			 *     Firebird.exclude('widget.button*').require('widget.*');
			 *
			 * {@link Firebird#exclude} is alias for {@link Firebird.Loader#exclude}.
			 *
			 * @param {Array} excludes
			 * @return {Object} object contains `require` method for chaining
			 */
			exclude: function (excludes) {
				return {
					require: function (expressions, fn, scope) {
						return Loader.require(expressions, fn, scope, excludes);
					},
					syncRequire: function (expressions, fn, scope) {
						return Loader.syncRequire(expressions, fn, scope, excludes);
					}
				};
			},
			/**
			 * Add a new listener to be executed when all required scripts are fully loaded
			 *
			 * @param {Function} fn The function callback to be executed
			 * @param {Object} scope The execution scope (<code>this</code>) of the callback function
			 * @param {Boolean} withDomReady Whether or not to wait for document dom ready as well
			 */
			onReady: function (fn, scope, withDomReady, options) {
				var oldFn;

				if (withDomReady !== false && Firebird.onDocumentReady) {
					oldFn = fn;

					fn = function () {
						Firebird.onDocumentReady(oldFn, scope, options);
					};
				}

				fn.call(scope);
			}
		});

		var queue = [],
			isClassFileLoaded = {},
			isFileLoaded = {},
			classNameToFilePathMap = {},
			scriptElements = {},
			readyListeners = [],
			usedClasses = [],
			requiresMap = {},
			comparePriority = function (listenerA, listenerB) {
				return listenerB.priority - listenerA.priority;
			};

		Firebird.apply(Loader, {
			/**
			 * @private
			 */
			documentHead: typeof document != 'undefined' && (document.head || document.getElementsByTagName('head')[0]),
			/**
			 * Flag indicating whether there are still files being loaded
			 * @private
			 */
			isLoading: false,
			/**
			 * Maintain the queue for all dependencies. Each item in the array is an object of the format:
			 *
			 *     {
             *          requires: [...], // The required classes for this queue item
             *          callback: function() { ... } // The function to execute when all classes specified in requires exist
             *     }
			 *
			 * @private
			 */
			queue: queue,
			/**
			 * Maintain the list of files that have already been handled so that they never get double-loaded
			 * @private
			 */
			isClassFileLoaded: isClassFileLoaded,
			/**
			 * @private
			 */
			isFileLoaded: isFileLoaded,
			/**
			 * Maintain the list of listeners to execute when all required scripts are fully loaded
			 * @private
			 */
			readyListeners: readyListeners,
			/**
			 * Contains classes referenced in `uses` properties.
			 * @private
			 */
			optionalRequires: usedClasses,
			/**
			 * Map of fully qualified class names to an array of dependent classes.
			 * @private
			 */
			requiresMap: requiresMap,
			/**
			 * @private
			 */
			numPendingFiles: 0,
			/**
			 * @private
			 */
			numLoadedFiles: 0,
			/** @private */
			hasFileLoadError: false,
			/**
			 * @private
			 */
			classNameToFilePathMap: classNameToFilePathMap,
			/**
			 * The number of scripts loading via loadScript.
			 * @private
			 */
			scriptsLoading: 0,
			/**
			 * @private
			 */
			syncModeEnabled: true,
			scriptElements: scriptElements,
			/**
			 * Refresh all items in the queue. If all dependencies for an item exist during looping,
			 * it will execute the callback and call refreshQueue again. Triggers onReady when the queue is
			 * empty
			 * @private
			 */
			refreshQueue: function () {
				var ln = queue.length,
					i, item, j, requires;

				// When the queue of loading classes reaches zero, trigger readiness

				if (!ln && !Loader.scriptsLoading) {
					return Loader.triggerReady();
				}

				for (i = 0; i < ln; i++) {
					item = queue[i];

					if (item) {
						requires = item.requires;

						// Don't bother checking when the number of files loaded
						// is still less than the array length
						if (requires.length > Loader.numLoadedFiles) {
							continue;
						}

						// Remove any required classes that are loaded
						for (j = 0; j < requires.length;) {
							if (Manager.isCreated(requires[j])) {
								// Take out from the queue
								arrayErase(requires, j, 1);
							}
							else {
								j++;
							}
						}

						// If we've ended up with no required classes, call the callback
						if (item.requires.length === 0) {
							arrayErase(queue, i, 1);
							item.callback.call(item.scope);
							Loader.refreshQueue();
							break;
						}
					}
				}

				return Loader;
			},
			/**
			 * Inject a script element to document's head, call onLoad and onError accordingly
			 * @private
			 */
			injectScriptElement: function (url, onLoad, onError, scope, charset) {


				var script = document.createElement('script'),
					dispatched = false,
					config = Loader.config,
					onLoadFn = function () {

						if (!dispatched) {
							dispatched = true;
							script.onload = script.onreadystatechange = script.onerror = null;
							if (typeof config.scriptChainDelay == 'number') {
								//free the stack (and defer the next script)
								defer(onLoad, config.scriptChainDelay, scope);
							} else {
								onLoad.call(scope);
							}
							Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
						}

					},
					onErrorFn = function (arg) {
						defer(onError, 1, scope);   //free the stack
						Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
					};


				require.async(url, onLoadFn);
				return;

			},
			/**
			 * @private
			 */
			removeScriptElement: function (url) {
				if (scriptElements[url]) {
					Loader.cleanupScriptElement(scriptElements[url], true, !!Loader.getConfig('garbageCollect'));
					delete scriptElements[url];
				}

				return Loader;
			},
			/**
			 * @private
			 */
			cleanupScriptElement: function (script, remove, collect) {
				var prop;
				script.onload = script.onreadystatechange = script.onerror = null;
				if (remove) {
					Firebird.removeNode(script);       // Remove, since its useless now
					if (collect) {
						for (prop in script) {
							try {
								if (prop != 'src') {
									// If we set the src property to null IE
									// will try and request a script at './null'
									script[prop] = null;
								}
								delete script[prop];      // and prepare for GC
							} catch (cleanEx) {
								//ignore
							}
						}
					}
				}

				return Loader;
			},
			/**
			 * Loads the specified script URL and calls the supplied callbacks. If this method
			 * is called before {@link Firebird#isReady}, the script's load will delay the transition
			 * to ready. This can be used to load arbitrary scripts that may contain further
			 * {@link Firebird#require Firebird.require} calls.
			 *
			 * @param {Object/String} options The options object or simply the URL to load.
			 * @param {String} options.url The URL from which to load the script.
			 * @param {Function} [options.onLoad] The callback to call on successful load.
			 * @param {Function} [options.onError] The callback to call on failure to load.
			 * @param {Object} [options.scope] The scope (`this`) for the supplied callbacks.
			 */
			loadScript: function (options) {
				var config = Loader.getConfig(),
					isString = typeof options == 'string',
					url = isString ? options : options.url,
					onError = !isString && options.onError,
					onLoad = !isString && options.onLoad,
					scope = !isString && options.scope,
					onScriptError = function () {
						Loader.numPendingFiles--;
						Loader.scriptsLoading--;

						if (onError) {
							onError.call(scope, "Failed loading '" + url + "', please verify that the file exists");
						}

						if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
							Loader.refreshQueue();
						}
					},
					onScriptLoad = function () {
						Loader.numPendingFiles--;
						Loader.scriptsLoading--;

						if (onLoad) {
							onLoad.call(scope);
						}

						if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
							Loader.refreshQueue();
						}
					},
					src;

				Loader.isLoading = true;
				Loader.numPendingFiles++;
				Loader.scriptsLoading++;

				src = config.disableCaching ?
					(url + '?' + config.disableCachingParam + '=' + Firebird.Date.now()) : url;

				scriptElements[url] = Loader.injectScriptElement(src, onScriptLoad, onScriptError);
			},
			/**
			 * Load a script file, supports both asynchronous and synchronous approaches
			 * @private
			 */
			// documented above
			syncRequire: function () {
				  console.log("aaaaa")

				var syncModeEnabled = Loader.syncModeEnabled;

				if (!syncModeEnabled) {
					Loader.syncModeEnabled = true;
				}

				Loader.require.apply(Loader, arguments);

				if (!syncModeEnabled) {
					Loader.syncModeEnabled = false;
				}

				Loader.refreshQueue();
			},
			// documented above
			require: function (expressions, fn, scope, excludes) {
				var excluded = {},
					included = {},
					excludedClassNames = [],
					possibleClassNames = [],
					classNames = [],
					references = [],
					callback,
					syncModeEnabled,
					filePath, expression, exclude, className,
					possibleClassName, i, j, ln, subLn;

				if (excludes) {
					// Convert possible single string to an array.
					excludes = (typeof excludes === 'string') ? [excludes] : excludes;

					for (i = 0, ln = excludes.length; i < ln; i++) {
						exclude = excludes[i];

						if (typeof exclude == 'string' && exclude.length > 0) {
							excludedClassNames = Manager.getNamesByExpression(exclude);

							for (j = 0, subLn = excludedClassNames.length; j < subLn; j++) {
								excluded[excludedClassNames[j]] = true;
							}
						}
					}
				}

				// Convert possible single string to an array.
				expressions = (typeof expressions === 'string') ? [expressions] : (expressions ? expressions : []);

				if (fn) {
					if (fn.length > 0) {
						callback = function () {
							var classes = [],
								i, ln;

							for (i = 0, ln = references.length; i < ln; i++) {
								classes.push(Manager.get(references[i]));
							}

							return fn.apply(this, classes);
						};
					}
					else {
						callback = fn;
					}
				}
				else {
					callback = Firebird.emptyFn;
				}

				scope = scope || Firebird.global;

				for (i = 0, ln = expressions.length; i < ln; i++) {
					expression = expressions[i];

					if (typeof expression == 'string' && expression.length > 0) {
						possibleClassNames = Manager.getNamesByExpression(expression);
						subLn = possibleClassNames.length;

						for (j = 0; j < subLn; j++) {
							possibleClassName = possibleClassNames[j];

							if (excluded[possibleClassName] !== true) {
								references.push(possibleClassName);

								if (!Manager.isCreated(possibleClassName) && !included[possibleClassName]) {
									included[possibleClassName] = true;
									classNames.push(possibleClassName);
								}
							}
						}
					}
				}

				// If the dynamic dependency feature is not being used, throw an error
				// if the dependencies are not defined
				if (classNames.length > 0) {
					if (!Loader.config.enabled) {
						firebird.error(new Error("请先加载 " + ((classNames.length > 1) ? "es" : "") + ": " + classNames.join(', ')));
					}
				}
				else {
					callback.call(scope);
					return Loader;
				}

				syncModeEnabled = Loader.syncModeEnabled;

				if (!syncModeEnabled) {
					queue.push({
						requires: classNames.slice(), // this array will be modified as the queue is processed,
						// so we need a copy of it
						callback: callback,
						scope: scope
					});
				}

				ln = classNames.length;

				for (i = 0; i < ln; i++) {
					className = classNames[i];

					filePath = Loader.getPath(className);

					// If we are synchronously loading a file that has already been asychronously loaded before
					// we need to destroy the script tag and revert the count
					// This file will then be forced loaded in synchronous
					if (syncModeEnabled && isClassFileLoaded.hasOwnProperty(className)) {
						if (!isClassFileLoaded[className]) {
							Loader.numPendingFiles--;
							Loader.removeScriptElement(filePath);
							delete isClassFileLoaded[className];
						}
					}

					if (!isClassFileLoaded.hasOwnProperty(className)) {
						isClassFileLoaded[className] = false;
						classNameToFilePathMap[className] = filePath;

						Loader.numPendingFiles++;
						Loader.loadScriptFile(
							filePath,
							pass(Loader.onFileLoaded, [className, filePath], Loader),
							pass(Loader.onFileLoadError, [className, filePath], Loader),
							Loader,
							syncModeEnabled
						);
					}
				}

				if (syncModeEnabled) {
					callback.call(scope);

					if (ln === 1) {
						return Manager.get(className);
					}
				}

				return Loader;
			},
			/**
			 * @private
			 * @param {String} className
			 * @param {String} filePath
			 */
			onFileLoaded: function (className, filePath) {
				var loaded = isClassFileLoaded[className];
				Loader.numLoadedFiles++;

				isClassFileLoaded[className] = true;
				isFileLoaded[filePath] = true;

				// In FF, when we sync load something that has had a script tag inserted, the load event may
				// sometimes fire even if we clean it up and set it to null, so check if we're already loaded here.
				if (!loaded) {
					Loader.numPendingFiles--;
				}

				if (Loader.numPendingFiles === 0) {
					Loader.refreshQueue();
				}

				if (!Loader.syncModeEnabled && Loader.numPendingFiles === 0 && Loader.isLoading && !Loader.hasFileLoadError) {
					var missingClasses = [],
						missingPaths = [],
						requires,
						i, ln, j, subLn;

					for (i = 0, ln = queue.length; i < ln; i++) {
						requires = queue[i].requires;

						for (j = 0, subLn = requires.length; j < subLn; j++) {
							if (isClassFileLoaded[requires[j]]) {
								missingClasses.push(requires[j]);
							}
						}
					}

					if (missingClasses.length < 1) {
						return;
					}

					missingClasses = Firebird.Array.filter(Firebird.Array.unique(missingClasses), function (item) {
						return !requiresMap.hasOwnProperty(item);
					}, Loader);

					if (missingClasses.length < 1) {
						return;
					}

					for (i = 0, ln = missingClasses.length; i < ln; i++) {
						missingPaths.push(classNameToFilePathMap[missingClasses[i]]);
					}

					firebird.error(new Error("以下类未被声明, 可能是相关文件没有下载" +
						": '" + missingClasses.join("', '") + "'. 看看是不是路径写错了 " +
						": '" + missingPaths.join("', '")));
				}
			},
			/**
			 * @private
			 */
			onFileLoadError: function (className, filePath, errorMessage, isSynchronous) {
				Loader.numPendingFiles--;
				Loader.hasFileLoadError = true;

				firebird.error(new Error("[Firebird.Loader] " + errorMessage));
			},
			/**
			 * @private
			 * Ensure that any classes referenced in the `uses` property are loaded.
			 */
			addUsedClasses: function (classes) {
				var cls, i, ln;

				if (classes) {
					classes = (typeof classes == 'string') ? [classes] : classes;
					for (i = 0, ln = classes.length; i < ln; i++) {
						cls = classes[i];
						if (typeof cls == 'string' && !Firebird.Array.contains(usedClasses, cls)) {
							usedClasses.push(cls);
						}
					}
				}

				return Loader;
			},
			/**
			 * @private
			 */
			triggerReady: function () {
				var listener,
					refClasses = usedClasses;

				if (Loader.isLoading) {
					Loader.isLoading = false;

					if (refClasses.length !== 0) {
						// Clone then empty the array to eliminate potential recursive loop issue
						refClasses = refClasses.slice();
						usedClasses.length = 0;
						// this may immediately call us back if all 'uses' classes
						// have been loaded
						Loader.require(refClasses, Loader.triggerReady, Loader);
						return Loader;
					}
				}

				Firebird.Array.sort(readyListeners, comparePriority);

				// this method can be called with Loader.isLoading either true or false
				// (can be called with false when all 'uses' classes are already loaded)
				// this may bypass the above if condition
				while (readyListeners.length && !Loader.isLoading) {
					// calls to refreshQueue may re-enter triggerReady
					// so we cannot necessarily iterate the readyListeners array
					listener = readyListeners.shift();
					listener.fn.call(listener.scope);
				}

				return Loader;
			},
			// Documented above already
			onReady: function (fn, scope, withDomReady, options) {
				var oldFn;

				if (withDomReady !== false && Firebird.onDocumentReady) {
					oldFn = fn;

					fn = function () {
						Firebird.onDocumentReady(oldFn, scope, options);
					};
				}

				if (!Loader.isLoading) {
					fn.call(scope);
				}
				else {
					readyListeners.push({
						fn: fn,
						scope: scope,
						priority: (options && options.priority) || 0
					});
				}
			},
			/**
			 * @private
			 * @param {String} className
			 */
			historyPush: function (className) {
				if (className && isClassFileLoaded.hasOwnProperty(className) && !isInHistory[className]) {
					isInHistory[className] = true;
					history.push(className);
				}
				return Loader;
			}
		});

		/**
		 * Turns on or off the "cache buster" applied to dynamically loaded scripts. Normally
		 * dynamically loaded scripts have an extra query parameter appended to avoid stale
		 * cached scripts. This method can be used to disable this mechanism, and is primarily
		 * useful for testing. This is done using a cookie.
		 * @param {Boolean} disable True to disable the cache buster.
		 * @param {String} [path="/"] An optional path to scope the cookie.
		 * @private
		 */
		Firebird.disableCacheBuster = function (disable, path) {
			var date = new Date();
			date.setTime(date.getTime() + (disable ? 10 * 365 : -1) * 24 * 60 * 60 * 1000);
			date = date.toGMTString();
			document.cookie = 'firebird-cache=1; expires=' + date + '; path=' + (path || '/');
		};

		/**
		 * @member Firebird
		 * @method require
		 * @inheritdoc Firebird.Loader#require
		 */
		Firebird.require = alias(Loader, 'require');

		/**
		 * @member Firebird
		 * @method syncRequire
		 * @inheritdoc Firebird.Loader#syncRequire
		 */
		Firebird.syncRequire = alias(Loader, 'syncRequire');

		/**
		 * Convenient shortcut to {@link Firebird.Loader#exclude}
		 * @member Firebird
		 * @method exclude
		 * @inheritdoc Firebird.Loader#exclude
		 */
		Firebird.exclude = alias(Loader, 'exclude');

		/**
		 * @member Firebird
		 * @method onReady
		 * @ignore
		 */
		Firebird.onReady = function (fn, scope, options) {
			Loader.onReady(fn, scope, true, options);
		};

		/**
		 * 在实例化当前类前加载列表中的类
		 * @cfg {String[]} requires
		 * @member Firebird.Class
		 * List of classes that have to be loaded before instantiating this class.
		 * 例子:
		 *
		 *     Firebird.define('Mother', {
         *         requires: ['Child'],
         *         giveBirth: function() {
         *             // we can be sure that child class is available.
         *             return new Child();
         *         }
         *     });
		 */
		Class.registerPreprocessor('loader', function (cls, data, hooks, continueFn) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(cls, 'Firebird.Loader#loaderPreprocessor', arguments);

			var me = this,
				dependencies = [],
				dependency,
				className = Manager.getName(cls),
				i, j, ln, subLn, value, propertyName, propertyValue,
				requiredMap, requiredDep;

			/*
			 Loop through the dependencyProperties, look for string class names and push
			 them into a stack, regardless of whether the property's value is a string, array or object. 例子:
			 {
			 extend: 'Firebird.MyClass',
			 requires: ['Firebird.some.OtherClass'],
			 mixins: {
			 observable: 'Firebird.util.Observable';
			 }
			 }
			 which will later be transformed into:
			 {
			 extend: Firebird.MyClass,
			 requires: [Firebird.some.OtherClass],
			 mixins: {
			 observable: Firebird.util.Observable;
			 }
			 }
			 */

			for (i = 0, ln = dependencyProperties.length; i < ln; i++) {
				propertyName = dependencyProperties[i];

				if (data.hasOwnProperty(propertyName)) {
					propertyValue = data[propertyName];

					if (typeof propertyValue == 'string') {
						dependencies.push(propertyValue);
					}
					else if (propertyValue instanceof Array) {
						for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
							value = propertyValue[j];

							if (typeof value == 'string') {
								dependencies.push(value);
							}
						}
					}
					else if (typeof propertyValue != 'function') {
						for (j in propertyValue) {
							if (propertyValue.hasOwnProperty(j)) {
								value = propertyValue[j];

								if (typeof value == 'string') {
									dependencies.push(value);
								}
							}
						}
					}
				}
			}

			if (dependencies.length === 0) {
				return;
			}

			var deadlockPath = [],
				detectDeadlock;

			/*
			 自动探测依赖死锁
			 Automatically detect deadlocks before-hand,
			 will throw an error with detailed path for ease of debugging. Examples of deadlock cases:

			 - A extends B, then B extends A
			 - A requires B, B requires C, then C requires A

			 The detectDeadlock function will recursively transverse till the leaf, hence it can detect deadlocks
			 no matter how deep the path is.
			 */

			if (className) {
				requiresMap[className] = dependencies;
				requiredMap = Loader.requiredByMap || (Loader.requiredByMap = {});

				for (i = 0, ln = dependencies.length; i < ln; i++) {
					dependency = dependencies[i];
					(requiredMap[dependency] || (requiredMap[dependency] = [])).push(className);
				}
				detectDeadlock = function (cls) {
					deadlockPath.push(cls);

					if (requiresMap[cls]) {
						if (Firebird.Array.contains(requiresMap[cls], className)) {
							firebird.error(new Error("加载依赖检测到死锁! '" + className + "' 与 '" +
								deadlockPath[1] + "' " + " 应该是相互依赖了. 路径: " +
								deadlockPath.join(' -> ') + " -> " + deadlockPath[0]));
						}

						for (i = 0, ln = requiresMap[cls].length; i < ln; i++) {
							detectDeadlock(requiresMap[cls][i]);
						}
					}
				};

				detectDeadlock(className);
			}

			Loader.require(dependencies, function () {
				for (i = 0, ln = dependencyProperties.length; i < ln; i++) {
					propertyName = dependencyProperties[i];

					if (data.hasOwnProperty(propertyName)) {
						propertyValue = data[propertyName];

						if (typeof propertyValue == 'string') {
							data[propertyName] = Manager.get(propertyValue);
						}
						else if (propertyValue instanceof Array) {
							for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
								value = propertyValue[j];

								if (typeof value == 'string') {
									data[propertyName][j] = Manager.get(value);
								}
							}
						}
						else if (typeof propertyValue != 'function') {
							for (var k in propertyValue) {
								if (propertyValue.hasOwnProperty(k)) {
									value = propertyValue[k];

									if (typeof value == 'string') {
										data[propertyName][k] = Manager.get(value);
									}
								}
							}
						}
					}
				}

				continueFn.call(me, cls, data, hooks);
			});

			return false;
		}, true, 'after', 'className');

		/**
		 * @cfg {String[]} uses
		 * @member Firebird.Class
		 * List of optional classes to load together with this class. These aren't neccessarily loaded before
		 * this class is created, but are guaranteed to be available before Firebird.onReady listeners are
		 * invoked. 例子:
		 *
		 *     Firebird.define('Mother', {
         *         uses: ['Child'],
         *         giveBirth: function() {
         *             // This code might, or might not work:
         *             // return new Child();
         *
         *             // Instead use Firebird.create() to load the class at the spot if not loaded already:
         *             return Firebird.create('Child');
         *         }
         *     });
		 */
		Manager.registerPostprocessor('uses', function (name, cls, data) {
			Firebird.classSystemMonitor && Firebird.classSystemMonitor(cls, 'Firebird.Loader#usesPostprocessor', arguments);

			var uses = data.uses;
			if (uses) {
				Loader.addUsedClasses(uses);
			}
		});

		Manager.onCreated(Loader.historyPush);
	};

// simple mechanism for automated means of injecting large amounts of dependency info
// at the appropriate time in the load cycle
	if (Firebird._classPathMetadata) {
		Firebird.Loader.addClassPathMappings(Firebird._classPathMetadata);
		Firebird._classPathMetadata = null;
	}

// initalize the default path of the framework
	(function () {
		return;
		var scripts = document.getElementsByTagName('script'),
			currentScript = scripts[scripts.length - 1],
			src = currentScript.src,
			path = src.substring(0, src.lastIndexOf('/') + 1),
			Loader = Firebird.Loader;

		if (src.indexOf("/resource/js/classes/") != -1) {
			path = path + "../../../../";
		} else if (src.indexOf("/resource/js/classes/") != -1) {
			path = path + "../../../";
		}
		Loader.setConfig({
			enabled: true,
			disableCaching: (/[?&](?:cache|disableCacheBuster)\b/i.test(location.search) ||
			/(^|[ ;])firebird-cache=1/.test(document.cookie)) ? false :
				true,
			paths: {
				'Firebird': path + 'component'
			}
		});
	})();

// allows a tools like dynatrace to deterministically detect onReady state by invoking
// a callback (intended for external consumption)
	Firebird._endTime = new Date().getTime();
	if (Firebird._beforereadyhandler) {
		Firebird._beforereadyhandler();
	}

	window.Firebird = Firebird;

	module.exports = Firebird;

});